Merged features/inband-usb r5224:6306 into trunk.

This is work-in-progress on inband signaling for the USRP1.


git-svn-id: http://gnuradio.org/svn/gnuradio/trunk@6307 221aa14e-8319-0410-a670-987f0aec2ac5

42 files changed, 8600 insertions, 332 deletions

diff --git a/usrp/host/apps/Makefile.am b/usrp/host/apps/Makefile.am
index f920ce59a..e0f5b8cf4 100644
--- a/usrp/host/apps/Makefile.am
+++ b/usrp/host/apps/Makefile.am
@@ -21,7 +21,10 @@
 
 include $(top_srcdir)/Makefile.common
 
-INCLUDES = $(USRP_INCLUDES) $(BOOST_CFLAGS)
+INCLUDES = 	\
+	$(DEFINES) $(OMNITHREAD_INCLUDES) $(PMT_INCLUDES) $(MBLOCK_INCLUDES) \
+	$(USRP_INCLUDES) $(BOOST_CFLAGS) $(CPPUNIT_INCLUDES)
+
 
 bin_PROGRAMS =				\
 	usrper				\
@@ -29,11 +32,20 @@ bin_PROGRAMS =				\
 
 noinst_PROGRAMS =			\
 	check_order_quickly		\
+	test_usrp_inband_cs		\
+	test_usrp_inband_ping		\
+	test_usrp_inband_registers	\
+	test_usrp_inband_rx		\
+	test_usrp_inband_tx		\
+	test_usrp_inband_timestamps	\
 	test_usrp_standard_rx		\
-	test_usrp_standard_tx		
+	test_usrp_standard_tx		\
+	read_packets
 
 noinst_HEADERS =			\
-	time_stuff.h
+	time_stuff.h			\
+	ui_nco.h			\
+	ui_sincos.h			
 
 noinst_PYTHON =				\
 	burn-db-eeprom			\
@@ -53,3 +65,24 @@ usrper_LDADD 			= $(USRP_LA)
 
 usrp_cal_dc_offset_SOURCES	= usrp_cal_dc_offset.cc
 usrp_cal_dc_offset_LDADD	= $(USRP_LA)
+
+test_usrp_inband_cs_SOURCES 	= test_usrp_inband_cs.cc time_stuff.c ui_sincos.c
+test_usrp_inband_cs_LDADD   	= $(USRP_LA)
+
+test_usrp_inband_ping_SOURCES 	= test_usrp_inband_ping.cc time_stuff.c
+test_usrp_inband_ping_LDADD   	= $(USRP_LA)
+
+test_usrp_inband_tx_SOURCES 	= test_usrp_inband_tx.cc time_stuff.c ui_sincos.c
+test_usrp_inband_tx_LDADD   	= $(USRP_LA)
+
+test_usrp_inband_timestamps_SOURCES 	= test_usrp_inband_timestamps.cc time_stuff.c ui_sincos.c
+test_usrp_inband_timestamps_LDADD   	= $(USRP_LA)
+
+test_usrp_inband_registers_SOURCES 	= test_usrp_inband_registers.cc time_stuff.c ui_sincos.c
+test_usrp_inband_registers_LDADD   	= $(USRP_LA)
+
+test_usrp_inband_rx_SOURCES 	= test_usrp_inband_rx.cc time_stuff.c ui_sincos.c
+test_usrp_inband_rx_LDADD   	= $(USRP_LA)
+
+read_packets_SOURCES = read_packets.cc
+read_packets_LDADD = $(USRP_LA)
diff --git a/usrp/host/apps/read_packets.cc b/usrp/host/apps/read_packets.cc
new file mode 100644
index 000000000..92d8baf0d
--- /dev/null
+++ b/usrp/host/apps/read_packets.cc
@@ -0,0 +1,103 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <iostream>
+#include <usrp_inband_usb_packet.h>
+#include <mb_class_registry.h>
+#include <vector>
+#include <usrp_usb_interface.h>
+#include <fstream>
+
+typedef usrp_inband_usb_packet transport_pkt;   // makes conversion to gigabit easy
+
+int main(int argc, char *argv[]) {
+
+  if(argc !=2) {
+    std::cout << "Usage: ./read_packets <data_file>\n";
+    return -1;
+  }
+
+  std::ifstream infile;
+  std::ofstream outfile;  
+
+  unsigned int pkt_size = transport_pkt::max_pkt_size();
+  unsigned int pkt_num=0;
+
+  transport_pkt *pkt;
+  char pkt_data[pkt_size];          // allocate the number of bytes for a single packet
+
+  pkt = (transport_pkt *)pkt_data;  // makes operations cleaner to read
+
+  // Open the file and read the packets, dumping information
+  infile.open(argv[1], std::ios::binary|std::ios::in);
+  if(!infile.is_open())
+    exit(-1);
+
+  //outfile.open("dump.dat",std::ios::out|std::ios::binary);  
+
+  // read 1 packet in to the memory
+  infile.read(pkt_data, pkt_size);
+
+  while(!infile.eof()) {
+  
+    printf("Packet %u\n", pkt_num);
+
+    if(pkt->start_of_burst())
+      printf("\tstart of burst\n");
+      
+    if(pkt->end_of_burst())
+      printf("\tend of burst\n");
+    
+//    if(pkt->carrier_sense())
+//      printf("\tcarrier sense\n");
+
+    printf("\tchannel: \t0x%x\n", pkt->chan());
+    printf("\ttimestamp: \t0x%x\n", pkt->timestamp());
+    //printf("\ttimestamp: \t%u\n", pkt->timestamp());
+    printf("\tlength: \t%u\n", pkt->payload_len());
+    printf("\trssi: \t%u\n", pkt->rssi());
+
+    printf("\tpayload: \n");
+    for(int i=0; i < pkt->payload_len(); i++)
+    //for(int i=0; i < pkt->max_payload(); i++)
+    {
+      printf("\t%d\t0x%x\n", i, *(pkt->payload()+i));
+      //outfile.write((const char*)(pkt->payload()+i),1);
+      //printf("\t\t0x%x\n", pkt->payload()+i);
+
+    }
+    printf("\n\n");
+
+    pkt_num++;
+  
+    // read 1 packet in to the memory
+    infile.read(pkt_data, pkt_size);
+
+  }
+
+  infile.close();
+  //outfile.close();
+
+}
diff --git a/usrp/host/apps/test_usrp_inband_cs.cc b/usrp/host/apps/test_usrp_inband_cs.cc
new file mode 100644
index 000000000..1d70341fe
--- /dev/null
+++ b/usrp/host/apps/test_usrp_inband_cs.cc
@@ -0,0 +1,478 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <mb_mblock.h>
+#include <mb_runtime.h>
+#include <mb_runtime_nop.h>		// QA only
+#include <mb_protocol_class.h>
+#include <mb_exception.h>
+#include <mb_msg_queue.h>
+#include <mb_message.h>
+#include <mb_mblock_impl.h>
+#include <mb_msg_accepter.h>
+#include <mb_class_registry.h>
+#include <pmt.h>
+#include <ui_nco.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+#include <iostream>
+
+#include <symbols_usrp_server_cs.h>
+#include <symbols_usrp_channel.h>
+#include <symbols_usrp_low_level_cs.h>
+#include <symbols_usrp_tx.h>
+#include <symbols_usrp_rx.h>
+
+#define NBPING  10
+
+static bool verbose = false;
+
+class test_usrp_cs : public mb_mblock
+{
+  mb_port_sptr 	d_tx;
+  mb_port_sptr 	d_rx;
+  mb_port_sptr 	d_cs;
+  pmt_t		d_tx_chan;	// returned tx channel handle
+  pmt_t		d_rx_chan;	// returned tx channel handle
+
+  struct timeval times[NBPING];
+
+  enum state_t {
+    INIT,
+    OPENING_USRP,
+    ALLOCATING_CHANNEL,
+    TRANSMITTING,
+    CLOSING_CHANNEL,
+    CLOSING_USRP,
+  };
+
+  state_t	d_state;
+  long		d_nsamples_to_send;
+  long		d_nsamples_xmitted;
+  long		d_nframes_xmitted;
+  long		d_samples_per_frame;
+  bool		d_done_sending;
+
+  // for generating sine wave output
+  ui_nco<float,float>	d_nco;
+  double	        d_amplitude;
+
+ public:
+  test_usrp_cs(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~test_usrp_cs();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void open_usrp();
+  void close_usrp();
+  void allocate_channel();
+  void send_packets();
+  void enter_receiving();
+  void enter_transmitting();
+  void build_and_send_ping();
+  void build_and_send_next_frame();
+  void handle_xmit_response(pmt_t invocation_handle);
+  void enter_closing_channel();
+};
+
+test_usrp_cs::test_usrp_cs(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg),
+    d_tx_chan(PMT_NIL),
+    d_rx_chan(PMT_NIL),
+    d_state(INIT), d_nsamples_to_send((long) 40e6),
+    d_nsamples_xmitted(0),
+    d_nframes_xmitted(0),
+    //d_samples_per_frame((long)(126)),
+    //d_samples_per_frame((long)(126 * 3.5)),	// non-full packet
+    d_samples_per_frame((long)(126 * 4)),	// full packet
+    d_done_sending(false),
+    d_amplitude(16384)
+{ 
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_CS] Initializing...\n";
+  
+  d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+  
+  //bool fake_usrp_p = true;
+  bool fake_usrp_p = false;
+
+  // Test the TX side
+
+  pmt_t usrp_dict = pmt_make_dict();
+
+  if(fake_usrp_p) {
+    pmt_dict_set(usrp_dict, 
+                 pmt_intern("fake-usrp"),
+		             PMT_T);
+  }
+
+  // Set TX and RX interpolations
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-tx"),
+               pmt_from_long(128));
+
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-rx"),
+               pmt_from_long(16));
+
+  // Specify the RBF to use
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rbf"),
+               pmt_intern("boe.rbf"));
+
+  define_component("server", "usrp_server", usrp_dict);
+
+  connect("self", "tx0", "server", "tx0");
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+
+  // initialize NCO
+  double freq = 100e3;
+  int interp = 32;			    // 32 -> 4MS/s
+  double sample_rate = 128e6 / interp;	
+  d_nco.set_freq(2*M_PI * freq/sample_rate);
+
+  // FIXME need to somehow set the interp rate in the USRP.
+  // for now, we'll have the low-level code hardwire it.
+}
+
+test_usrp_cs::~test_usrp_cs()
+{
+}
+
+void
+test_usrp_cs::initial_transition()
+{
+  open_usrp();
+}
+
+void
+test_usrp_cs::handle_message(mb_message_sptr msg)
+{
+  pmt_t	event = msg->signal();
+  pmt_t data = msg->data();
+  pmt_t port_id = msg->port_id();
+
+  pmt_t handle = PMT_F;
+  pmt_t status = PMT_F;
+  std::string error_msg;
+  
+  //std::cout << msg << std::endl;
+
+  switch(d_state){
+  case OPENING_USRP:
+    if (pmt_eq(event, s_response_open)){
+      status = pmt_nth(1, data);
+      if (pmt_eq(status, PMT_T)){
+        allocate_channel();
+        return;
+      }
+      else {
+        error_msg = "failed to open usrp:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+    
+  case ALLOCATING_CHANNEL:
+    if (pmt_eq(event, s_response_allocate_channel)){
+
+      if(pmt_eq(d_tx->port_symbol(), port_id)) {
+        status = pmt_nth(1, data);
+        d_tx_chan = pmt_nth(2, data);
+
+        if (pmt_eq(status, PMT_T)){
+
+          if(verbose)
+            std::cout << "[TEST_USRP_INBAND_CS] Received allocation for TX\n";
+
+          if(!pmt_eqv(d_rx_chan, PMT_NIL)) {
+            enter_receiving();
+            enter_transmitting();
+          }
+          return;
+        }
+        else {
+          error_msg = "failed to allocate channel:";
+          goto bail;
+        }
+      }
+      
+      if(pmt_eq(d_rx->port_symbol(), port_id)) {
+        status = pmt_nth(1, data);
+        d_rx_chan = pmt_nth(2, data);
+
+        if (pmt_eq(status, PMT_T)){
+
+          if(verbose)
+            std::cout << "[TEST_USRP_INBAND_CS] Received allocation for TX\n";
+          
+          if(!pmt_eqv(d_tx_chan, PMT_NIL)) {
+            enter_receiving();
+            enter_transmitting();
+          }
+          return;
+        }
+        else {
+          error_msg = "failed to allocate channel:";
+          goto bail;
+        }
+      }
+    }
+    goto unhandled;
+
+  case TRANSMITTING:
+    if (pmt_eq(event, s_response_xmit_raw_frame)){
+      handle = pmt_nth(0, data);
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+        handle_xmit_response(handle);
+        return;
+      }
+      else {
+        error_msg = "bad response-xmit-raw-frame:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+
+  case CLOSING_CHANNEL:
+    if (pmt_eq(event, s_response_deallocate_channel)){
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+        close_usrp();
+        return;
+      }
+      else {
+        error_msg = "failed to deallocate channel:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+
+  case CLOSING_USRP:
+    if (pmt_eq(event, s_response_close)){
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+        shutdown_all(PMT_T);
+        return;
+      }
+      else {
+        error_msg = "failed to close USRP:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+
+  default:
+    goto unhandled;
+  }
+  return;
+
+ bail:
+  std::cerr << error_msg << data
+	    << "status = " << status << std::endl;
+  shutdown_all(PMT_F);
+  return;
+
+ unhandled:
+  if(verbose)
+    std::cout << "test_usrp_inband_tx: unhandled msg: " << msg
+              << "in state "<< d_state << std::endl;
+}
+
+
+void
+test_usrp_cs::open_usrp()
+{
+  pmt_t which_usrp = pmt_from_long(0);
+
+  d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, which_usrp));
+  d_state = OPENING_USRP;
+}
+
+void
+test_usrp_cs::close_usrp()
+{
+  d_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
+  d_state = CLOSING_USRP;
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_CS] Closing USRP\n";
+}
+
+void
+test_usrp_cs::allocate_channel()
+{
+  long capacity = (long) 16e6;
+  d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+  d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+  d_state = ALLOCATING_CHANNEL;
+}
+
+void
+test_usrp_cs::enter_receiving()
+{
+  d_rx->send(s_cmd_start_recv_raw_samples,
+             pmt_list2(PMT_F,
+                       d_rx_chan));
+}
+
+void
+test_usrp_cs::enter_transmitting()
+{
+  d_state = TRANSMITTING;
+  d_nsamples_xmitted = 0;
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_CS] Beginning transmission\n";
+
+  sleep(1);
+
+//  build_and_send_next_frame();	// fire off 4 to start pipeline
+
+  build_and_send_ping();
+  build_and_send_ping();
+  build_and_send_ping();
+  
+}
+
+void
+test_usrp_cs::build_and_send_ping()
+{
+  
+  d_tx->send(s_cmd_to_control_channel,
+             pmt_list2(PMT_NIL, pmt_list1(pmt_list2(s_op_ping_fixed,
+                                                    pmt_list2(pmt_from_long(0),
+                                                              pmt_from_long(0))))));
+
+  std::cout << "[TEST_USRP_INBAND_CS] Ping sent" << std::endl;
+}
+
+void
+test_usrp_cs::build_and_send_next_frame()
+{
+  // allocate the uniform vector for the samples
+  // FIXME perhaps hold on to this between calls
+
+#if 1
+  long nsamples_this_frame =
+    std::min(d_nsamples_to_send - d_nsamples_xmitted,
+	     d_samples_per_frame);
+#else
+  long nsamples_this_frame = d_samples_per_frame;
+#endif
+
+  if (nsamples_this_frame == 0){
+    d_done_sending = true;
+    return;
+  }
+    
+
+  size_t nshorts = 2 * nsamples_this_frame;	// 16-bit I & Q
+  pmt_t uvec = pmt_make_s16vector(nshorts, 0);
+  size_t ignore;
+  int16_t *samples = pmt_s16vector_writeable_elements(uvec, ignore);
+
+  // fill in the complex sinusoid
+
+  for (int i = 0; i < nsamples_this_frame; i++){
+
+    if (1){
+      gr_complex s;
+      d_nco.sincos(&s, 1, d_amplitude);
+      // write 16-bit i & q
+      samples[2*i] =   (int16_t) s.real();
+      samples[2*i+1] = (int16_t) s.imag();
+    }
+    else {
+      gr_complex s(d_amplitude, d_amplitude);
+
+      // write 16-bit i & q
+      samples[2*i] =   (int16_t) s.real();
+      samples[2*i+1] = (int16_t) s.imag();
+    }
+  }
+
+  pmt_t timestamp = pmt_from_long(0xffffffff);	// NOW
+  d_tx->send(s_cmd_xmit_raw_frame,
+	     pmt_list4(pmt_from_long(d_nframes_xmitted),  // invocation-handle
+		       d_tx_chan,			  // channel
+		       uvec,				  // the samples
+		       timestamp));
+
+  d_nsamples_xmitted += nsamples_this_frame;
+  d_nframes_xmitted++;
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_CS] Transmitted frame\n";
+}
+
+
+void
+test_usrp_cs::handle_xmit_response(pmt_t handle)
+{
+  if (d_done_sending &&
+      pmt_to_long(handle) == (d_nframes_xmitted - 1)){
+    // We're done sending and have received all responses
+    enter_closing_channel();
+  }
+
+  //build_and_send_next_frame();
+}
+
+void
+test_usrp_cs::enter_closing_channel()
+{
+  d_state = CLOSING_CHANNEL;
+  
+  d_tx->send(s_cmd_deallocate_channel, pmt_list2(PMT_NIL, d_tx_chan));
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_CS] Closing channel\n";
+}
+
+REGISTER_MBLOCK_CLASS(test_usrp_cs);
+
+
+// ----------------------------------------------------------------
+
+int
+main (int argc, char **argv)
+{
+  // handle any command line args here
+
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_NIL;
+
+  rt->run("top", "test_usrp_cs", PMT_F, &result);
+}
diff --git a/usrp/host/apps/test_usrp_inband_ping.cc b/usrp/host/apps/test_usrp_inband_ping.cc
new file mode 100644
index 000000000..a68f49272
--- /dev/null
+++ b/usrp/host/apps/test_usrp_inband_ping.cc
@@ -0,0 +1,376 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <mb_mblock.h>
+#include <mb_runtime.h>
+#include <mb_runtime_nop.h>		// QA only
+#include <mb_protocol_class.h>
+#include <mb_exception.h>
+#include <mb_msg_queue.h>
+#include <mb_message.h>
+#include <mb_mblock_impl.h>
+#include <mb_msg_accepter.h>
+#include <mb_class_registry.h>
+#include <pmt.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+#include <iostream>
+
+// Include the symbols needed for communication with USRP server
+#include <symbols_usrp_server_cs.h>
+#include <symbols_usrp_channel.h>
+#include <symbols_usrp_low_level_cs.h>
+#include <symbols_usrp_tx.h>
+#include <symbols_usrp_rx.h>
+
+static bool verbose = false;
+
+class test_usrp_inband_ping : public mb_mblock
+{
+
+  mb_port_sptr  d_tx;   // Ports connected to the USRP server
+  mb_port_sptr  d_rx;
+  mb_port_sptr  d_cs;
+
+  pmt_t   d_tx_chan;    // Returned channel from TX allocation
+  pmt_t   d_rx_chan;    // Returned channel from RX allocation
+
+  pmt_t   d_which_usrp; // The USRP to use for the test
+
+  long    d_warm_msgs;  // The number of messages to 'warm' the USRP
+  long    d_warm_recvd; // The number of msgs received in the 'warm' state
+
+  // Keep track of current state
+  enum state_t {
+    INIT,
+    OPENING_USRP,
+    ALLOCATING_CHANNELS,
+    WARMING_USRP,
+    PINGING,
+    CLOSING_CHANNELS,
+    CLOSING_USRP,
+  };
+  state_t d_state;
+
+ public:
+  test_usrp_inband_ping(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~test_usrp_inband_ping();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void opening_usrp();
+  void allocating_channels();
+  void enter_warming_usrp();
+  void enter_pinging();
+  void build_and_send_ping();
+  void closing_channels();
+  void closing_usrp();
+};
+
+
+int
+main (int argc, char **argv)
+{
+  // handle any command line args here
+
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_NIL;
+
+  rt->run("top", "test_usrp_inband_ping", PMT_F, &result);
+}
+
+
+test_usrp_inband_ping::test_usrp_inband_ping(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg),
+  d_tx_chan(PMT_NIL),
+  d_rx_chan(PMT_NIL),
+  d_which_usrp(pmt_from_long(0)),
+  d_state(INIT)
+{
+  
+  // A dictionary is used to pass parameters to the USRP
+  pmt_t usrp_dict = pmt_make_dict();
+
+  // Specify the RBF to use
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rbf"),
+               pmt_intern("fixed1.rbf"));
+
+  // Set TX and RX interpolations
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-tx"),
+               pmt_from_long(128));
+
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-rx"),
+               pmt_from_long(16));
+  
+  d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+
+  // Create an instance of USRP server and connect ports
+  define_component("server", "usrp_server", usrp_dict);
+  connect("self", "tx0", "server", "tx0");
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+
+}
+
+test_usrp_inband_ping::~test_usrp_inband_ping()
+{
+}
+
+void
+test_usrp_inband_ping::initial_transition()
+{
+  opening_usrp();
+}
+
+// Handle message reads all incoming messages from USRP server which will be
+// initialization and ping responses.  We perform actions based on the current
+// state and the event (ie, ping response)
+void
+test_usrp_inband_ping::handle_message(mb_message_sptr msg)
+{
+  pmt_t event = msg->signal();
+  pmt_t data = msg->data();
+  pmt_t port_id = msg->port_id();
+
+  pmt_t handle = PMT_F;
+  pmt_t status = PMT_F;
+  std::string error_msg;
+
+  // Dispatch based on state
+  switch(d_state) {
+
+    //----------------------------- OPENING_USRP ----------------------------//
+    // We only expect a response from opening the USRP which should be succesful
+    // or failed.
+    case OPENING_USRP:
+      
+      if(pmt_eq(event, s_response_open)) {
+
+        status = pmt_nth(1, data);          // failed/succes
+        
+        if(pmt_eq(status, PMT_T)) {
+          allocating_channels();
+          return;
+        }
+        else {
+          error_msg = "failed to open usrp:";
+          goto bail;
+        }
+
+      }
+
+      goto unhandled;   // all other messages not handled in this state
+      
+    
+    //----------------------- ALLOCATING CHANNELS --------------------//
+    // When allocating channels, we need to wait for 2 responses from
+    // USRP server: one for TX and one for RX.  Both are initialized to
+    // NIL so we know to continue to the next state once both are set.
+    case ALLOCATING_CHANNELS:
+
+      // A TX allocation response
+      if(pmt_eq(event, s_response_allocate_channel)
+          && pmt_eq(d_tx->port_symbol(), port_id)) 
+      {
+        status = pmt_nth(1, data);
+        
+        // If successful response, extract the channel
+        if(pmt_eq(status, PMT_T)) {
+          
+          d_tx_chan = pmt_nth(2, data);
+
+          if(verbose)
+            std::cout << "[TEST_USRP_INBAND_PING] Received TX allocation"
+                      << " on channel " << d_tx_chan << std::endl;
+
+          // If the RX has also been allocated already, we can continue
+          if(!pmt_eqv(d_rx_chan, PMT_NIL)) 
+            enter_warming_usrp();
+
+          return;
+        }
+        else {  // TX allocation failed
+          error_msg = "failed to allocate TX channel:";
+          goto bail;
+        }
+      }
+      
+      // A RX allocation response
+      if(pmt_eq(event, s_response_allocate_channel)
+          && pmt_eq(d_rx->port_symbol(), port_id)) 
+      {
+        status = pmt_nth(1, data);
+        
+        // If successful response, extract the channel
+        if(pmt_eq(status, PMT_T)) {
+          
+          d_rx_chan = pmt_nth(2, data);
+
+          if(verbose)
+            std::cout << "[TEST_USRP_INBAND_PING] Received RX allocation"
+                      << " on channel " << d_rx_chan << std::endl;
+
+          // If the TX has also been allocated already, we can continue
+          if(!pmt_eqv(d_tx_chan, PMT_NIL)) 
+            enter_warming_usrp();
+
+          return;
+        }
+        else {  // RX allocation failed
+          error_msg = "failed to allocate RX channel:";
+          goto bail;
+        }
+      }
+
+      goto unhandled;
+
+    //----------------------- WARMING USRP --------------------//
+    // The FX2 seems to need some amount of data to be buffered
+    // before it begins reading.  We use this state to simply
+    // warm up the USRP before benchmarking pings.
+    case WARMING_USRP:
+
+      // We really don't care about the responses from the
+      // control channel in the warming stage, but once we receive
+      // the proper number of responses we switch states.
+      if(pmt_eq(event, s_response_from_control_channel)
+          && pmt_eq(d_rx->port_symbol(), port_id))
+      {
+        d_warm_recvd++;
+
+        if(d_warm_recvd > d_warm_msgs)
+          enter_pinging();
+
+        return;
+      }
+
+      goto unhandled;
+
+    case PINGING:
+      goto unhandled;
+
+    case CLOSING_CHANNELS:
+      goto unhandled;
+
+    case CLOSING_USRP:
+      goto unhandled;
+
+    case INIT:
+      goto unhandled;
+
+  }
+ 
+ // An error occured, print it, and shutdown all m-blocks
+ bail:
+  std::cerr << error_msg << data
+      	    << "status = " << status << std::endl;
+  shutdown_all(PMT_F);
+  return;
+
+ // Received an unhandled message for a specific state
+ unhandled:
+  if(verbose)
+    std::cout << "test_usrp_inband_tx: unhandled msg: " << msg
+              << "in state "<< d_state << std::endl;
+
+}
+
+
+// Sends a command to USRP server to open up a connection to the
+// specified USRP, which is defaulted to USRP 0 on the system
+void
+test_usrp_inband_ping::opening_usrp()
+{
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_PING] Opening USRP " 
+              << d_which_usrp << std::endl;
+
+  d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, d_which_usrp));
+  d_state = OPENING_USRP;
+}
+
+// RX and TX channels must be allocated so that the USRP server can
+// properly share bandwidth across multiple USRPs.  No commands will be
+// successful to the USRP through the USRP server on the TX or RX channels until
+// a bandwidth allocation has been received.
+void
+test_usrp_inband_ping::allocating_channels()
+{
+  d_state = ALLOCATING_CHANNELS;
+
+  long capacity = (long) 16e6;
+  d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+  d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+}
+
+// The USRP needs some amount of initial data to pass a buffering point such
+// that it begins to pull and read data from the FX2.  We send an arbitrary
+// amount of data to start the pipeline, which are just pings.
+void
+test_usrp_inband_ping::enter_warming_usrp()
+{
+  d_state = WARMING_USRP;
+
+  for(int i=0; i < d_warm_msgs; i++)
+    build_and_send_ping();
+}
+
+void
+test_usrp_inband_ping::enter_pinging()
+{
+  d_state = PINGING;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_PING] Running ping tests\n";
+
+}
+
+// Pings are sent over the TX channel using the signal 'cmd-to-control-channel'
+// to the USRP server.  Within this message there can be infinite subpackets
+// stored as a list (the second parameter) and sent.  The only subpacket we send
+// is a ping, interpreted by the 'op-ping-fixed' signal.
+void
+test_usrp_inband_ping::build_and_send_ping()
+{
+  
+  d_tx->send(s_cmd_to_control_channel,    // USRP server signal
+             pmt_list2(PMT_NIL,           // invocation handle 
+                       pmt_list1(pmt_list3(s_op_ping_fixed, 
+                                           pmt_from_long(0), 
+                                           pmt_from_long(0)))));
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_PING] Ping!!" << std::endl;
+}
+
+REGISTER_MBLOCK_CLASS(test_usrp_inband_ping);
diff --git a/usrp/host/apps/test_usrp_inband_registers.cc b/usrp/host/apps/test_usrp_inband_registers.cc
new file mode 100644
index 000000000..922b6215d
--- /dev/null
+++ b/usrp/host/apps/test_usrp_inband_registers.cc
@@ -0,0 +1,436 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <mb_mblock.h>
+#include <mb_runtime.h>
+#include <mb_runtime_nop.h>		// QA only
+#include <mb_protocol_class.h>
+#include <mb_exception.h>
+#include <mb_msg_queue.h>
+#include <mb_message.h>
+#include <mb_mblock_impl.h>
+#include <mb_msg_accepter.h>
+#include <mb_class_registry.h>
+#include <pmt.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+#include <iostream>
+
+// Include the symbols needed for communication with USRP server
+#include <symbols_usrp_server_cs.h>
+#include <symbols_usrp_channel.h>
+#include <symbols_usrp_low_level_cs.h>
+#include <symbols_usrp_tx.h>
+#include <symbols_usrp_rx.h>
+
+static bool verbose = true;
+
+class test_usrp_inband_registers : public mb_mblock
+{
+
+  mb_port_sptr  d_tx;   // Ports connected to the USRP server
+  mb_port_sptr  d_rx;
+  mb_port_sptr  d_cs;
+
+  pmt_t   d_tx_chan;    // Returned channel from TX allocation
+  pmt_t   d_rx_chan;    // Returned channel from RX allocation
+
+  pmt_t   d_which_usrp; // The USRP to use for the test
+
+  long    d_warm_msgs;  // The number of messages to 'warm' the USRP
+  long    d_warm_recvd; // The number of msgs received in the 'warm' state
+
+  // Keep track of current state
+  enum state_t {
+    INIT,
+    OPENING_USRP,
+    ALLOCATING_CHANNELS,
+    WRITE_REGISTER,
+    READ_REGISTER,
+    CLOSING_CHANNELS,
+    CLOSING_USRP,
+  };
+  state_t d_state;
+
+ public:
+  test_usrp_inband_registers(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~test_usrp_inband_registers();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void opening_usrp();
+  void allocating_channels();
+  void write_register();
+  void read_register();
+  void closing_channels();
+  void closing_usrp();
+  void enter_receiving();
+  void build_and_send_ping();
+};
+
+
+int
+main (int argc, char **argv)
+{
+  // handle any command line args here
+
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_NIL;
+
+  rt->run("top", "test_usrp_inband_registers", PMT_F, &result);
+}
+
+
+test_usrp_inband_registers::test_usrp_inband_registers(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg),
+  d_tx_chan(PMT_NIL),
+  d_rx_chan(PMT_NIL),
+  d_which_usrp(pmt_from_long(0)),
+  d_state(INIT)
+{
+  
+  // A dictionary is used to pass parameters to the USRP
+  pmt_t usrp_dict = pmt_make_dict();
+
+  // Specify the RBF to use
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rbf"),
+               pmt_intern("boe2.rbf"));
+
+  // Set TX and RX interpolations
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-tx"),
+               pmt_from_long(128));
+
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-rx"),
+               pmt_from_long(16));
+  
+  d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+
+  // Create an instance of USRP server and connect ports
+  define_component("server", "usrp_server", usrp_dict);
+  connect("self", "tx0", "server", "tx0");
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+
+}
+
+test_usrp_inband_registers::~test_usrp_inband_registers()
+{
+}
+
+void
+test_usrp_inband_registers::initial_transition()
+{
+  opening_usrp();
+}
+
+// Handle message reads all incoming messages from USRP server which will be
+// initialization and ping responses.  We perform actions based on the current
+// state and the event (ie, ping response)
+void
+test_usrp_inband_registers::handle_message(mb_message_sptr msg)
+{
+  pmt_t event = msg->signal();
+  pmt_t data = msg->data();
+  pmt_t port_id = msg->port_id();
+
+  pmt_t handle = PMT_F;
+  pmt_t status = PMT_F;
+  std::string error_msg;
+
+  // Dispatch based on state
+  switch(d_state) {
+
+    //----------------------------- OPENING_USRP ----------------------------//
+    // We only expect a response from opening the USRP which should be succesful
+    // or failed.
+    case OPENING_USRP:
+      
+      if(pmt_eq(event, s_response_open)) {
+
+        status = pmt_nth(1, data);          // failed/succes
+        
+        if(pmt_eq(status, PMT_T)) {
+          allocating_channels();
+          return;
+        }
+        else {
+          error_msg = "failed to open usrp:";
+          goto bail;
+        }
+
+      }
+
+      goto unhandled;   // all other messages not handled in this state
+      
+    
+    //----------------------- ALLOCATING CHANNELS --------------------//
+    // When allocating channels, we need to wait for 2 responses from
+    // USRP server: one for TX and one for RX.  Both are initialized to
+    // NIL so we know to continue to the next state once both are set.
+    case ALLOCATING_CHANNELS:
+
+      // A TX allocation response
+      if(pmt_eq(event, s_response_allocate_channel)
+          && pmt_eq(d_tx->port_symbol(), port_id)) 
+      {
+        status = pmt_nth(1, data);
+        
+        // If successful response, extract the channel
+        if(pmt_eq(status, PMT_T)) {
+          
+          d_tx_chan = pmt_nth(2, data);
+
+          if(verbose)
+            std::cout << "[TEST_USRP_INBAND_PING] Received TX allocation"
+                      << " on channel " << d_tx_chan << std::endl;
+
+          // If the RX has also been allocated already, we can continue
+          if(!pmt_eqv(d_rx_chan, PMT_NIL)) {
+            enter_receiving();
+            write_register();
+          }
+
+          return;
+        }
+        else {  // TX allocation failed
+          error_msg = "failed to allocate TX channel:";
+          goto bail;
+        }
+      }
+      
+      // A RX allocation response
+      if(pmt_eq(event, s_response_allocate_channel)
+          && pmt_eq(d_rx->port_symbol(), port_id)) 
+      {
+        status = pmt_nth(1, data);
+        
+        // If successful response, extract the channel
+        if(pmt_eq(status, PMT_T)) {
+          
+          d_rx_chan = pmt_nth(2, data);
+
+          if(verbose)
+            std::cout << "[TEST_USRP_INBAND_PING] Received RX allocation"
+                      << " on channel " << d_rx_chan << std::endl;
+
+          // If the TX has also been allocated already, we can continue
+          if(!pmt_eqv(d_tx_chan, PMT_NIL)) {
+            enter_receiving();
+            write_register();
+          }
+
+          return;
+        }
+        else {  // RX allocation failed
+          error_msg = "failed to allocate RX channel:";
+          goto bail;
+        }
+      }
+
+      goto unhandled;
+
+    //-------------------------- WRITE REGISTER ----------------------------//
+    // In the write register state, we do not expect to receive any messages
+    // since the write does not directly generate a response until the USRP
+    // responds.
+    case WRITE_REGISTER:
+      goto unhandled;
+
+    //-------------------------- READ REGISTER ----------------------------//
+    // In the read register state, we only expect a read register response back
+    // that has the value we expect to have in it.  We read the response, ensure
+    // that the read was successful and display the register value.
+    case READ_REGISTER:
+
+      if(pmt_eq(event, s_response_from_control_channel)
+          && pmt_eq(d_tx->port_symbol(), port_id))
+      {
+        status = pmt_nth(1, data);
+
+        // If the read was successful, we extract the subpacket information
+        if(pmt_eq(status, PMT_T)) {
+          
+          pmt_t subp = pmt_nth(2, data);      // subpacket should be the read reg reply
+
+          pmt_t subp_sig  = pmt_nth(0, subp);
+          pmt_t subp_data = pmt_nth(1, subp);
+
+          if(!pmt_eqv(subp_sig, s_op_read_reg_reply)) {
+            error_msg = "received improper subpacket when expecting reg reply.";
+            goto bail;
+          }
+
+          pmt_t rid     = pmt_nth(0, subp_data);
+          pmt_t reg_num = pmt_nth(1, subp_data);
+          pmt_t reg_val = pmt_nth(2, subp_data);
+
+          if(verbose)
+            std::cout << "[TEST_USRP_INBAND_REGISTERS] Received read reg reply "
+                      << "("
+                      << "RID: " << rid << ", " 
+                      << "Reg: " << reg_num << ", "
+                      << "Val: " << reg_val
+                      << ")\n";
+          
+          // read_register();  FIX ME STATE TRANSITION
+          return;
+
+        } else {  // bail on unsuccessful write
+          error_msg = "failed to write to register.";
+          goto bail;
+        }
+      }
+      goto unhandled;
+
+    case CLOSING_CHANNELS:
+      goto unhandled;
+
+    case CLOSING_USRP:
+      goto unhandled;
+
+    case INIT:
+      goto unhandled;
+
+  }
+ 
+ // An error occured, print it, and shutdown all m-blocks
+ bail:
+  std::cerr << error_msg << data
+      	    << "status = " << status << std::endl;
+  shutdown_all(PMT_F);
+  return;
+
+ // Received an unhandled message for a specific state
+ unhandled:
+  if(verbose && !pmt_eq(event, s_response_recv_raw_samples))
+    std::cout << "test_usrp_inband_tx: unhandled msg: " << msg
+              << "in state "<< d_state << std::endl;
+
+}
+
+
+// Sends a command to USRP server to open up a connection to the
+// specified USRP, which is defaulted to USRP 0 on the system
+void
+test_usrp_inband_registers::opening_usrp()
+{
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_PING] Opening USRP " 
+              << d_which_usrp << std::endl;
+
+  d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, d_which_usrp));
+  d_state = OPENING_USRP;
+}
+
+// RX and TX channels must be allocated so that the USRP server can
+// properly share bandwidth across multiple USRPs.  No commands will be
+// successful to the USRP through the USRP server on the TX or RX channels until
+// a bandwidth allocation has been received.
+void
+test_usrp_inband_registers::allocating_channels()
+{
+  d_state = ALLOCATING_CHANNELS;
+
+  long capacity = (long) 16e6;
+  d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+  d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+}
+
+// After allocating the channels, a write register command will be sent to the
+// USRP.
+void
+test_usrp_inband_registers::write_register()
+{
+  d_state = WRITE_REGISTER;
+
+  long reg = 0;
+
+  d_tx->send(s_cmd_to_control_channel,    // C/S packet
+             pmt_list2(PMT_NIL,           // invoc handle
+                       pmt_list1(
+                            pmt_list2(s_op_write_reg, 
+                                      pmt_list2(
+                                      pmt_from_long(reg), 
+                                      pmt_from_long(0xbeef))))));
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_REGISTERS] Writing 0xbeef to " 
+              << reg << std::endl;
+
+  read_register();  // immediately transition to read the register
+}
+
+// Temporary: for testing pings
+void
+test_usrp_inband_registers::build_and_send_ping()
+{
+  
+  d_tx->send(s_cmd_to_control_channel,
+             pmt_list2(PMT_NIL, pmt_list1(pmt_list2(s_op_ping_fixed,
+                                                    pmt_list2(pmt_from_long(0),
+                                                              pmt_from_long(0))))));
+
+  std::cout << "[TEST_USRP_INBAND_CS] Ping sent" << std::endl;
+}
+
+// After writing to the register, we want to read the value back and ensure that
+// it is the same value that we wrote.
+void
+test_usrp_inband_registers::read_register()
+{
+  d_state = READ_REGISTER;
+
+  long reg = 9;
+
+  d_tx->send(s_cmd_to_control_channel,    // C/S packet
+             pmt_list2(PMT_NIL,           // invoc handle
+                       pmt_list1(
+                            pmt_list2(s_op_read_reg, 
+                                      pmt_list2(
+                                      pmt_from_long(0),   // rid 
+                                      pmt_from_long(reg))))));
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_REGISTERS] Reading from register " 
+              << reg << std::endl;
+}
+
+// Used to enter the receiving state
+void
+test_usrp_inband_registers::enter_receiving()
+{
+  d_rx->send(s_cmd_start_recv_raw_samples,
+             pmt_list2(PMT_F,
+                       d_rx_chan));
+}
+
+REGISTER_MBLOCK_CLASS(test_usrp_inband_registers);
diff --git a/usrp/host/apps/test_usrp_inband_rx.cc b/usrp/host/apps/test_usrp_inband_rx.cc
new file mode 100644
index 000000000..4820c2d4e
--- /dev/null
+++ b/usrp/host/apps/test_usrp_inband_rx.cc
@@ -0,0 +1,356 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <mb_mblock.h>
+#include <mb_runtime.h>
+#include <mb_runtime_nop.h>		// QA only
+#include <mb_protocol_class.h>
+#include <mb_exception.h>
+#include <mb_msg_queue.h>
+#include <mb_message.h>
+#include <mb_mblock_impl.h>
+#include <mb_msg_accepter.h>
+#include <mb_class_registry.h>
+#include <pmt.h>
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+
+// Signal set for the USRP server
+static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel");
+static pmt_t s_cmd_close = pmt_intern("cmd-close");
+static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel");
+static pmt_t s_cmd_open = pmt_intern("cmd-open");
+static pmt_t s_cmd_start_recv_raw_samples = pmt_intern("cmd-start-recv-raw-samples");
+static pmt_t s_cmd_stop_recv_raw_samples = pmt_intern("cmd-stop-recv-raw-samples");
+static pmt_t s_cmd_to_control_channel = pmt_intern("cmd-to-control-channel");
+static pmt_t s_cmd_xmit_raw_frame  = pmt_intern("cmd-xmit-raw-frame");
+static pmt_t s_cmd_max_capacity  = pmt_intern("cmd-max-capacity");
+static pmt_t s_cmd_ntx_chan  = pmt_intern("cmd-ntx-chan");
+static pmt_t s_cmd_nrx_chan  = pmt_intern("cmd-nrx-chan");
+static pmt_t s_cmd_current_capacity_allocation  = pmt_intern("cmd-current-capacity-allocation");
+static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel");
+static pmt_t s_response_close = pmt_intern("response-close");
+static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel");
+static pmt_t s_response_from_control_channel = pmt_intern("response-from-control-channel");
+static pmt_t s_response_open = pmt_intern("response-open");
+static pmt_t s_response_recv_raw_samples = pmt_intern("response-recv-raw-samples");
+static pmt_t s_response_xmit_raw_frame = pmt_intern("response-xmit-raw-frame");
+static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity");
+static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan");
+static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan");
+static pmt_t s_response_current_capacity_allocation  = pmt_intern("response-current-capacity-allocation");
+
+static bool verbose = false;
+
+class test_usrp_rx : public mb_mblock
+{
+  mb_port_sptr 	d_rx;
+  mb_port_sptr 	d_cs;
+  pmt_t		d_rx_chan;	// returned tx channel handle
+
+  bool d_disk_write;
+
+  enum state_t {
+    INIT,
+    OPENING_USRP,
+    ALLOCATING_CHANNEL,
+    RECEIVING,
+    CLOSING_CHANNEL,
+    CLOSING_USRP,
+  };
+
+  state_t	d_state;
+
+  std::ofstream d_ofile;
+
+ public:
+  test_usrp_rx(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~test_usrp_rx();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void open_usrp();
+  void close_usrp();
+  void allocate_channel();
+  void send_packets();
+  void enter_receiving();
+  void build_and_send_next_frame();
+  void handle_response_recv_raw_samples(pmt_t invocation_handle);
+  void enter_closing_channel();
+};
+
+test_usrp_rx::test_usrp_rx(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg),
+  d_disk_write(false)
+{ 
+  
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+  
+  //bool fake_usrp_p = true;
+  bool fake_usrp_p = false;
+  
+  d_disk_write = true;
+
+  // Test the TX side
+
+  // Pass a dictionary to usrp_server which specifies which interface to use, the stub or USRP
+  pmt_t usrp_dict = pmt_make_dict();
+
+  if(fake_usrp_p)
+    pmt_dict_set(usrp_dict, 
+                 pmt_intern("fake-usrp"),
+		             PMT_T);
+  
+  // Specify the RBF to use
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rbf"),
+               pmt_intern("tmac6.rbf"));
+
+  // Set TX and RX interpolations
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-tx"),
+               pmt_from_long(128));
+
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-rx"),
+               pmt_from_long(16));
+
+  define_component("server", "usrp_server", usrp_dict);
+
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+
+  if(d_disk_write)
+    d_ofile.open("pdump_rx.dat",std::ios::binary|std::ios::out);
+}
+
+test_usrp_rx::~test_usrp_rx()
+{
+  if(d_disk_write)
+    d_ofile.close();
+}
+
+void
+test_usrp_rx::initial_transition()
+{
+  open_usrp();
+}
+
+void
+test_usrp_rx::handle_message(mb_message_sptr msg)
+{
+  pmt_t	event = msg->signal();
+  pmt_t data = msg->data();
+
+  pmt_t handle = PMT_F;
+  pmt_t status = PMT_F;
+  std::string error_msg;
+  
+  switch(d_state){
+  case OPENING_USRP:
+    if (pmt_eq(event, s_response_open)){
+      status = pmt_nth(1, data);
+      if (pmt_eq(status, PMT_T)){
+        allocate_channel();
+        return;
+      }
+      else {
+        error_msg = "failed to open usrp:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+    
+  case ALLOCATING_CHANNEL:
+    if (pmt_eq(event, s_response_allocate_channel)){
+      status = pmt_nth(1, data);
+      d_rx_chan = pmt_nth(2, data);
+
+      if (pmt_eq(status, PMT_T)){
+        enter_receiving();
+        return;
+      }
+      else {
+        error_msg = "failed to allocate channel:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+
+  case RECEIVING:
+    if (pmt_eq(event, s_response_recv_raw_samples)){
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+        handle_response_recv_raw_samples(data);
+        return;
+      }
+      else {
+        error_msg = "bad response-xmit-raw-frame:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+
+  case CLOSING_CHANNEL:
+    if (pmt_eq(event, s_response_deallocate_channel)){
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+        close_usrp();
+        return;
+      }
+      else {
+        error_msg = "failed to deallocate channel:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+
+  case CLOSING_USRP:
+    if (pmt_eq(event, s_response_close)){
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+        shutdown_all(PMT_T);
+        return;
+      }
+      else {
+        error_msg = "failed to close USRP:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+
+  default:
+    goto unhandled;
+  }
+  return;
+
+ bail:
+  std::cerr << error_msg << data
+	    << "status = " << status << std::endl;
+  shutdown_all(PMT_F);
+  return;
+
+ unhandled:
+  std::cout << "test_usrp_inband_rx: unhandled msg: " << msg
+	    << "in state "<< d_state << std::endl;
+}
+
+
+void
+test_usrp_rx::open_usrp()
+{
+  pmt_t which_usrp = pmt_from_long(0);
+
+  d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, which_usrp));
+  d_state = OPENING_USRP;
+}
+
+void
+test_usrp_rx::close_usrp()
+{
+  d_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
+  d_state = CLOSING_USRP;
+}
+
+void
+test_usrp_rx::allocate_channel()
+{
+  long capacity = (long) 16e6;
+  d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+  d_state = ALLOCATING_CHANNEL;
+}
+
+void
+test_usrp_rx::enter_receiving()
+{
+  d_state = RECEIVING;
+
+  d_rx->send(s_cmd_start_recv_raw_samples,
+             pmt_list2(PMT_F,
+                       d_rx_chan));
+}
+
+void
+test_usrp_rx::handle_response_recv_raw_samples(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+  pmt_t v_samples = pmt_nth(2, data);
+  pmt_t timestamp = pmt_nth(3, data);
+  pmt_t properties = pmt_nth(4, data);
+
+  size_t n_bytes;
+  
+  const char *samples = (const char *) pmt_uniform_vector_elements(v_samples, n_bytes);
+
+  if(d_disk_write)
+    d_ofile.write(samples, n_bytes);
+
+  if(verbose)
+    std::cout << ".";
+
+  if (pmt_is_dict(properties)) {
+    // Read the RSSI
+    if(pmt_t rssi = pmt_dict_ref(properties, 
+                                 pmt_intern("rssi"), 
+                                 PMT_NIL)) {
+      if(!pmt_eqv(rssi, PMT_NIL)) 
+        std::cout << "RSSI: " << rssi << std::endl;
+    }
+  }
+  
+
+}
+
+void
+test_usrp_rx::enter_closing_channel()
+{
+  d_state = CLOSING_CHANNEL;
+  
+  d_rx->send(s_cmd_deallocate_channel, pmt_list2(PMT_NIL, d_rx_chan));
+}
+
+REGISTER_MBLOCK_CLASS(test_usrp_rx);
+
+
+// ----------------------------------------------------------------
+
+int
+main (int argc, char **argv)
+{
+  // handle any command line args here
+
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_NIL;
+
+  rt->run("top", "test_usrp_rx", PMT_F, &result);
+}
diff --git a/usrp/host/apps/test_usrp_inband_timestamps.cc b/usrp/host/apps/test_usrp_inband_timestamps.cc
new file mode 100644
index 000000000..d48c2a789
--- /dev/null
+++ b/usrp/host/apps/test_usrp_inband_timestamps.cc
@@ -0,0 +1,508 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <mb_mblock.h>
+#include <mb_runtime.h>
+#include <mb_runtime_nop.h>		// QA only
+#include <mb_protocol_class.h>
+#include <mb_exception.h>
+#include <mb_msg_queue.h>
+#include <mb_message.h>
+#include <mb_mblock_impl.h>
+#include <mb_msg_accepter.h>
+#include <mb_class_registry.h>
+#include <pmt.h>
+#include <ui_nco.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+#include <iostream>
+
+#include <symbols_usrp_server_cs.h>
+#include <symbols_usrp_channel.h>
+#include <symbols_usrp_low_level_cs.h>
+#include <symbols_usrp_tx.h>
+#include <symbols_usrp_rx.h>
+
+#define NBPING  10
+
+static bool verbose = true;
+bool bskip = false;
+long bstep = 10000;
+long bcurr = 0;
+long incr = 0x500;
+long ptime = 0x000;
+
+class test_usrp_inband_timestamps : public mb_mblock
+{
+  mb_port_sptr 	d_tx;
+  mb_port_sptr 	d_rx;
+  mb_port_sptr 	d_cs;
+  pmt_t		d_tx_chan;	// returned tx channel handle
+  pmt_t		d_rx_chan;	// returned tx channel handle
+
+  struct timeval times[NBPING];
+
+  enum state_t {
+    INIT,
+    OPENING_USRP,
+    ALLOCATING_CHANNEL,
+    TRANSMITTING,
+    CLOSING_CHANNEL,
+    CLOSING_USRP,
+  };
+
+  state_t	d_state;
+  long		d_nsamples_to_send;
+  long		d_nsamples_xmitted;
+  long		d_nframes_xmitted;
+  long		d_samples_per_frame;
+  bool		d_done_sending;
+
+  // for generating sine wave output
+  ui_nco<float,float>	d_nco;
+  double	        d_amplitude;
+
+ public:
+  test_usrp_inband_timestamps(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~test_usrp_inband_timestamps();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void open_usrp();
+  void close_usrp();
+  void allocate_channel();
+  void send_packets();
+  void enter_receiving();
+  void enter_transmitting();
+  void build_and_send_ping();
+  void build_and_send_next_frame();
+  void handle_xmit_response(pmt_t invocation_handle);
+  void enter_closing_channel();
+};
+
+test_usrp_inband_timestamps::test_usrp_inband_timestamps(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg),
+    d_tx_chan(PMT_NIL),
+    d_rx_chan(PMT_NIL),
+    d_state(INIT), d_nsamples_to_send((long) 40e6),
+    d_nsamples_xmitted(0),
+    d_nframes_xmitted(0),
+    //d_samples_per_frame((long)(126)),
+    d_samples_per_frame((long)(126 * 2)),	// non-full packet
+    //d_samples_per_frame((long)(126 * 3.5)),	// non-full packet
+    //d_samples_per_frame((long)(126 * 4)),	// full packet
+    d_done_sending(false),
+    d_amplitude(16384)
+{ 
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_TIMESTAMPS] Initializing...\n";
+  
+  d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+  
+  bool fake_usrp_p = false;
+
+  // Test the TX side
+
+  pmt_t usrp_dict = pmt_make_dict();
+
+  if(fake_usrp_p) {
+    pmt_dict_set(usrp_dict, 
+                 pmt_intern("fake-usrp"),
+		             PMT_T);
+  }
+
+  // Set TX and RX interpolations
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-tx"),
+               pmt_from_long(128));
+
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-rx"),
+               pmt_from_long(16));
+
+  // Specify the RBF to use
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rbf"),
+               pmt_intern("tmac5.rbf"));
+
+  define_component("server", "usrp_server", usrp_dict);
+
+  connect("self", "tx0", "server", "tx0");
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+
+  // initialize NCO
+  double freq = 100e3;
+  int interp = 32;			    // 32 -> 4MS/s
+  double sample_rate = 128e6 / interp;	
+  d_nco.set_freq(2*M_PI * freq/sample_rate);
+
+}
+
+test_usrp_inband_timestamps::~test_usrp_inband_timestamps()
+{
+}
+
+void
+test_usrp_inband_timestamps::initial_transition()
+{
+  open_usrp();
+}
+
+void
+test_usrp_inband_timestamps::handle_message(mb_message_sptr msg)
+{
+  pmt_t	event = msg->signal();
+  pmt_t data = msg->data();
+  pmt_t port_id = msg->port_id();
+
+  pmt_t handle = PMT_F;
+  pmt_t status = PMT_F;
+  std::string error_msg;
+  
+  //std::cout << msg << std::endl;
+
+  switch(d_state){
+  case OPENING_USRP:
+    if (pmt_eq(event, s_response_open)){
+      status = pmt_nth(1, data);
+      if (pmt_eq(status, PMT_T)){
+        allocate_channel();
+        return;
+      }
+      else {
+        error_msg = "failed to open usrp:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+    
+  case ALLOCATING_CHANNEL:
+    if (pmt_eq(event, s_response_allocate_channel)){
+
+      if(pmt_eq(d_tx->port_symbol(), port_id)) {
+        status = pmt_nth(1, data);
+        d_tx_chan = pmt_nth(2, data);
+
+        if (pmt_eq(status, PMT_T)){
+
+          if(verbose)
+            std::cout << "[TEST_USRP_INBAND_TIMESTAMPS] Received allocation for TX\n";
+
+          if(!pmt_eqv(d_rx_chan, PMT_NIL)) {
+            enter_receiving();
+            enter_transmitting();
+          }
+          return;
+        }
+        else {
+          error_msg = "failed to allocate channel:";
+          goto bail;
+        }
+      }
+      
+      if(pmt_eq(d_rx->port_symbol(), port_id)) {
+        status = pmt_nth(1, data);
+        d_rx_chan = pmt_nth(2, data);
+
+        if (pmt_eq(status, PMT_T)){
+
+          if(verbose)
+            std::cout << "[TEST_USRP_INBAND_TIMESTAMPS] Received allocation for TX\n";
+          
+          if(!pmt_eqv(d_tx_chan, PMT_NIL)) {
+            enter_receiving();
+            enter_transmitting();
+          }
+          return;
+        }
+        else {
+          error_msg = "failed to allocate channel:";
+          goto bail;
+        }
+      }
+    }
+    goto unhandled;
+
+  case TRANSMITTING:
+    if (pmt_eq(event, s_response_xmit_raw_frame)){
+      handle = pmt_nth(0, data);
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+        handle_xmit_response(handle);
+        return;
+      }
+      else {
+        error_msg = "bad response-xmit-raw-frame:";
+        goto bail;
+      }
+    }
+
+    if (pmt_eq(event, s_response_from_control_channel)) {
+      std::cout << "ping response!\n";
+    }
+    goto unhandled;
+
+  case CLOSING_CHANNEL:
+    if (pmt_eq(event, s_response_deallocate_channel)){
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+        close_usrp();
+        return;
+      }
+      else {
+        error_msg = "failed to deallocate channel:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+
+  case CLOSING_USRP:
+    if (pmt_eq(event, s_response_close)){
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+        shutdown_all(PMT_T);
+        return;
+      }
+      else {
+        error_msg = "failed to close USRP:";
+        goto bail;
+      }
+    }
+    goto unhandled;
+
+  default:
+    goto unhandled;
+  }
+  return;
+
+ bail:
+  std::cerr << error_msg << data
+	    << "status = " << status << std::endl;
+  shutdown_all(PMT_F);
+  return;
+
+ unhandled:
+  if(verbose && 0)
+    std::cout << "test_usrp_inband_tx: unhandled msg: " << msg
+              << "in state "<< d_state << std::endl;
+}
+
+
+void
+test_usrp_inband_timestamps::open_usrp()
+{
+  pmt_t which_usrp = pmt_from_long(0);
+
+  d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, which_usrp));
+  d_state = OPENING_USRP;
+}
+
+void
+test_usrp_inband_timestamps::close_usrp()
+{
+  d_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
+  d_state = CLOSING_USRP;
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_TIMESTAMPS] Closing USRP\n";
+}
+
+void
+test_usrp_inband_timestamps::allocate_channel()
+{
+  long capacity = (long) 16e6;
+  d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+  d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+  d_state = ALLOCATING_CHANNEL;
+}
+
+void
+test_usrp_inband_timestamps::enter_receiving()
+{
+  d_rx->send(s_cmd_start_recv_raw_samples,
+             pmt_list2(PMT_F,
+                       d_rx_chan));
+}
+
+void
+test_usrp_inband_timestamps::enter_transmitting()
+{
+  d_state = TRANSMITTING;
+  d_nsamples_xmitted = 0;
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_TIMESTAMPS] Beginning transmission\n";
+
+  sleep(1);
+
+  build_and_send_next_frame();
+  build_and_send_next_frame();
+  build_and_send_next_frame();
+  build_and_send_next_frame();
+
+}
+
+void
+test_usrp_inband_timestamps::build_and_send_ping()
+{
+  
+  d_tx->send(s_cmd_to_control_channel,
+             pmt_list2(PMT_NIL, pmt_list1(pmt_list2(s_op_ping_fixed,
+                                                    pmt_list2(pmt_from_long(0),
+                                                              pmt_from_long(0))))));
+  if(verbose && 0)
+    std::cout << "[TEST_USRP_INBAND_TIMESTAMPS] Ping sent" << std::endl;
+}
+
+void
+test_usrp_inband_timestamps::build_and_send_next_frame()
+{
+  // allocate the uniform vector for the samples
+  // FIXME perhaps hold on to this between calls
+
+#if 0
+  long nsamples_this_frame =
+    std::min(d_nsamples_to_send - d_nsamples_xmitted,
+	     d_samples_per_frame);
+#else
+  long nsamples_this_frame = d_samples_per_frame;
+#endif
+
+  if (nsamples_this_frame == 0){
+    d_done_sending = true;
+    return;
+  }
+    
+
+  size_t nshorts = 2 * nsamples_this_frame;	// 16-bit I & Q
+  pmt_t uvec = pmt_make_s16vector(nshorts, 0);
+  size_t ignore;
+  int16_t *samples = pmt_s16vector_writeable_elements(uvec, ignore);
+
+  // fill in the complex sinusoid
+
+  for (int i = 0; i < nsamples_this_frame; i++){
+
+    if (1){
+      gr_complex s;
+      d_nco.sincos(&s, 1, d_amplitude);
+      // write 16-bit i & q
+      samples[2*i] =   (int16_t) s.real();
+      samples[2*i+1] = (int16_t) s.imag();
+    }
+    else {
+      gr_complex s(d_amplitude, d_amplitude);
+
+      // write 16-bit i & q
+      samples[2*i] =   (int16_t) s.real();
+      samples[2*i+1] = (int16_t) s.imag();
+    }
+  }
+
+  pmt_t timestamp;
+
+  if(bskip) {
+    timestamp = pmt_from_long(0x0);	// throw away  
+    bcurr++;
+    if(bcurr == bstep) {
+      bskip = false;
+      bcurr = 0;
+    }
+  } else {
+    timestamp = pmt_from_long(0xffffffff);	// NOW
+    timestamp = pmt_from_long(ptime);
+    ptime += incr;
+    bcurr++;
+    if(bcurr == bstep) {
+      //bskip = true;
+      bcurr = 0;
+    }
+  }
+
+  std::cout << bskip << " -- " << bcurr << std::endl;
+
+  d_tx->send(s_cmd_xmit_raw_frame,
+	     pmt_list4(pmt_from_long(d_nframes_xmitted),  // invocation-handle
+		       d_tx_chan,			  // channel
+		       uvec,				  // the samples
+		       timestamp));
+
+  d_nsamples_xmitted += nsamples_this_frame;
+  d_nframes_xmitted++;
+
+  if(verbose && 0)
+    std::cout << "[TEST_USRP_INBAND_TIMESTAMPS] Transmitted frame\n";
+  
+  //build_and_send_next_frame();
+}
+
+
+void
+test_usrp_inband_timestamps::handle_xmit_response(pmt_t handle)
+{
+  if (d_done_sending &&
+      pmt_to_long(handle) == (d_nframes_xmitted - 1)){
+    // We're done sending and have received all responses
+    enter_closing_channel();
+  }
+
+  build_and_send_next_frame();
+  //build_and_send_ping();
+}
+
+void
+test_usrp_inband_timestamps::enter_closing_channel()
+{
+  d_state = CLOSING_CHANNEL;
+  
+  d_tx->send(s_cmd_deallocate_channel, pmt_list2(PMT_NIL, d_tx_chan));
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_TIMESTAMPS] Closing channel\n";
+}
+
+REGISTER_MBLOCK_CLASS(test_usrp_inband_timestamps);
+
+
+// ----------------------------------------------------------------
+
+int
+main (int argc, char **argv)
+{
+  // handle any command line args here
+
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_NIL;
+
+  rt->run("top", "test_usrp_inband_timestamps", PMT_F, &result);
+}
diff --git a/usrp/host/apps/test_usrp_inband_tx.cc b/usrp/host/apps/test_usrp_inband_tx.cc
new file mode 100644
index 000000000..18d36213b
--- /dev/null
+++ b/usrp/host/apps/test_usrp_inband_tx.cc
@@ -0,0 +1,409 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <mb_mblock.h>
+#include <mb_runtime.h>
+#include <mb_runtime_nop.h>		// QA only
+#include <mb_protocol_class.h>
+#include <mb_exception.h>
+#include <mb_msg_queue.h>
+#include <mb_message.h>
+#include <mb_mblock_impl.h>
+#include <mb_msg_accepter.h>
+#include <mb_class_registry.h>
+#include <pmt.h>
+#include <ui_nco.h>
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+
+#include <symbols_usrp_server_cs.h>
+#include <symbols_usrp_channel.h>
+#include <symbols_usrp_low_level_cs.h>
+#include <symbols_usrp_tx.h>
+
+static bool verbose = false;
+
+class test_usrp_tx : public mb_mblock
+{
+  mb_port_sptr 	d_tx;
+  mb_port_sptr 	d_cs;
+  pmt_t		d_tx_chan;	// returned tx channel handle
+
+  enum state_t {
+    INIT,
+    OPENING_USRP,
+    ALLOCATING_CHANNEL,
+    TRANSMITTING,
+    CLOSING_CHANNEL,
+    CLOSING_USRP,
+  };
+
+  state_t	d_state;
+  long		d_nsamples_to_send;
+  long		d_nsamples_xmitted;
+  long		d_nframes_xmitted;
+  long		d_samples_per_frame;
+  bool		d_done_sending;
+
+  // for generating sine wave output
+  ui_nco<float,float>	d_nco;
+  double	        d_amplitude;
+
+ public:
+  test_usrp_tx(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~test_usrp_tx();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void open_usrp();
+  void close_usrp();
+  void allocate_channel();
+  void send_packets();
+  void enter_transmitting();
+  void build_and_send_next_frame();
+  void handle_xmit_response(pmt_t invocation_handle);
+  void enter_closing_channel();
+};
+
+test_usrp_tx::test_usrp_tx(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg),
+    d_state(INIT), d_nsamples_to_send((long) 40e6),
+    d_nsamples_xmitted(0),
+    d_nframes_xmitted(0),
+    //d_samples_per_frame((long)(126)),
+    //d_samples_per_frame((long)(126 * 3.5)),	// non-full packet
+    d_samples_per_frame((long)(126 * 4)),	// full packet
+    d_done_sending(false),
+    d_amplitude(16384)
+{ 
+  // std::cout << "[TEST_USRP_TX] Initializing...\n";
+  
+  d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+  
+  //bool fake_usrp_p = true;
+  bool fake_usrp_p = false;
+
+  // Test the TX side
+
+  pmt_t usrp_dict = pmt_make_dict();
+
+  if(fake_usrp_p) {
+    pmt_dict_set(usrp_dict, 
+                 pmt_intern("fake-usrp"),
+		             PMT_T);
+  }
+  
+  // Specify the RBF to use
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rbf"),
+               pmt_intern("boe3.rbf"));
+
+  // Set TX and RX interpolations
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-tx"),
+               pmt_from_long(128));
+
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-rx"),
+               pmt_from_long(16));
+  
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rf-freq"),
+               pmt_from_long(10e6));
+
+  define_component("server", "usrp_server", usrp_dict);
+
+  connect("self", "tx0", "server", "tx0");
+  connect("self", "cs", "server", "cs");
+
+  // initialize NCO
+  double freq = 100e3;
+  int interp = 32;			    // 32 -> 4MS/s
+  double sample_rate = 128e6 / interp;	
+  d_nco.set_freq(2*M_PI * freq/sample_rate);
+
+  // FIXME need to somehow set the interp rate in the USRP.
+  // for now, we'll have the low-level code hardwire it.
+}
+
+test_usrp_tx::~test_usrp_tx()
+{
+}
+
+void
+test_usrp_tx::initial_transition()
+{
+  open_usrp();
+}
+
+void
+test_usrp_tx::handle_message(mb_message_sptr msg)
+{
+  pmt_t	event = msg->signal();
+  pmt_t data = msg->data();
+
+  pmt_t handle = PMT_F;
+  pmt_t status = PMT_F;
+  std::string error_msg;
+  
+  //std::cout << msg << std::endl;
+
+  switch(d_state){
+  case OPENING_USRP:
+    if (pmt_eq(event, s_response_open)){
+      status = pmt_nth(1, data);
+      if (pmt_eq(status, PMT_T)){
+	allocate_channel();
+	return;
+      }
+      else {
+	error_msg = "failed to open usrp:";
+	goto bail;
+      }
+    }
+    goto unhandled;
+    
+  case ALLOCATING_CHANNEL:
+    if (pmt_eq(event, s_response_allocate_channel)){
+      status = pmt_nth(1, data);
+      d_tx_chan = pmt_nth(2, data);
+
+      if (pmt_eq(status, PMT_T)){
+	enter_transmitting();
+	return;
+      }
+      else {
+	error_msg = "failed to allocate channel:";
+	goto bail;
+      }
+    }
+    goto unhandled;
+
+  case TRANSMITTING:
+    if (pmt_eq(event, s_response_xmit_raw_frame)){
+      handle = pmt_nth(0, data);
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+	handle_xmit_response(handle);
+	return;
+      }
+      else {
+	error_msg = "bad response-xmit-raw-frame:";
+	goto bail;
+      }
+    }
+    goto unhandled;
+
+  case CLOSING_CHANNEL:
+    if (pmt_eq(event, s_response_deallocate_channel)){
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+	close_usrp();
+	return;
+      }
+      else {
+	error_msg = "failed to deallocate channel:";
+	goto bail;
+      }
+    }
+    goto unhandled;
+
+  case CLOSING_USRP:
+    if (pmt_eq(event, s_response_close)){
+      status = pmt_nth(1, data);
+
+      if (pmt_eq(status, PMT_T)){
+	shutdown_all(PMT_T);
+	return;
+      }
+      else {
+	error_msg = "failed to close USRP:";
+	goto bail;
+      }
+    }
+    goto unhandled;
+
+  default:
+    goto unhandled;
+  }
+  return;
+
+ bail:
+  std::cerr << error_msg << data
+	    << "status = " << status << std::endl;
+  shutdown_all(PMT_F);
+  return;
+
+ unhandled:
+  std::cout << "test_usrp_inband_tx: unhandled msg: " << msg
+	    << "in state "<< d_state << std::endl;
+}
+
+
+void
+test_usrp_tx::open_usrp()
+{
+  pmt_t which_usrp = pmt_from_long(0);
+
+  d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, which_usrp));
+  d_state = OPENING_USRP;
+}
+
+void
+test_usrp_tx::close_usrp()
+{
+  d_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
+  d_state = CLOSING_USRP;
+}
+
+void
+test_usrp_tx::allocate_channel()
+{
+  long capacity = (long) 16e6;
+  d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+  d_state = ALLOCATING_CHANNEL;
+}
+
+void
+test_usrp_tx::enter_transmitting()
+{
+  d_state = TRANSMITTING;
+  d_nsamples_xmitted = 0;
+  
+  // FIXME: carrier sense hack
+//  d_tx->send(s_cmd_to_control_channel,    // C/S packet
+//             pmt_list2(PMT_NIL,           // invoc handle
+//                       pmt_list1(
+//                            pmt_list2(s_op_write_reg, 
+//                                      pmt_list2(
+//                                      pmt_from_long(1), 
+//                                      pmt_from_long(0))))));
+
+  build_and_send_next_frame();	// fire off 4 to start pipeline
+  build_and_send_next_frame();
+  build_and_send_next_frame();
+  build_and_send_next_frame();
+}
+
+void
+test_usrp_tx::build_and_send_next_frame()
+{
+  // allocate the uniform vector for the samples
+  // FIXME perhaps hold on to this between calls
+
+#if 1
+  long nsamples_this_frame =
+    std::min(d_nsamples_to_send - d_nsamples_xmitted,
+	     d_samples_per_frame);
+#else
+  long nsamples_this_frame = d_samples_per_frame;
+#endif
+
+  if (nsamples_this_frame == 0){
+    d_done_sending = true;
+    return;
+  }
+    
+
+  size_t nshorts = 2 * nsamples_this_frame;	// 16-bit I & Q
+  pmt_t uvec = pmt_make_s16vector(nshorts, 0);
+  size_t ignore;
+  int16_t *samples = pmt_s16vector_writeable_elements(uvec, ignore);
+
+  // fill in the complex sinusoid
+
+  for (int i = 0; i < nsamples_this_frame; i++){
+
+    if (1){
+      gr_complex s;
+      d_nco.sincos(&s, 1, d_amplitude);
+      // write 16-bit i & q
+      samples[2*i] =   (int16_t) s.real();
+      samples[2*i+1] = (int16_t) s.imag();
+    }
+    else {
+      gr_complex s(d_amplitude, d_amplitude);
+
+      // write 16-bit i & q
+      samples[2*i] =   (int16_t) s.real();
+      samples[2*i+1] = (int16_t) s.imag();
+    }
+  }
+
+  pmt_t timestamp = pmt_from_long(0xffffffff);	// NOW
+  d_tx->send(s_cmd_xmit_raw_frame,
+	     pmt_list4(pmt_from_long(d_nframes_xmitted),  // invocation-handle
+		       d_tx_chan,			  // channel
+		       uvec,				  // the samples
+		       timestamp));
+
+  d_nsamples_xmitted += nsamples_this_frame;
+  d_nframes_xmitted++;
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_TX] Transmitted frame\n";
+}
+
+
+void
+test_usrp_tx::handle_xmit_response(pmt_t handle)
+{
+  if (d_done_sending &&
+      pmt_to_long(handle) == (d_nframes_xmitted - 1)){
+    // We're done sending and have received all responses
+    enter_closing_channel();
+  }
+
+  build_and_send_next_frame();
+}
+
+void
+test_usrp_tx::enter_closing_channel()
+{
+  d_state = CLOSING_CHANNEL;
+  
+  d_tx->send(s_cmd_deallocate_channel, pmt_list2(PMT_NIL, d_tx_chan));
+}
+
+REGISTER_MBLOCK_CLASS(test_usrp_tx);
+
+
+// ----------------------------------------------------------------
+
+int
+main (int argc, char **argv)
+{
+  // handle any command line args here
+
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_NIL;
+
+  rt->run("top", "test_usrp_tx", PMT_F, &result);
+}
diff --git a/usrp/host/apps/ui_nco.h b/usrp/host/apps/ui_nco.h
new file mode 100644
index 000000000..e6d7814ab
--- /dev/null
+++ b/usrp/host/apps/ui_nco.h
@@ -0,0 +1,202 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2002 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+#ifndef INCLUDED_UI_NCO_H
+#define INCLUDED_UI_NCO_H
+
+
+#include <vector>
+#include <ui_sincos.h>
+#include <cmath>
+
+#include <complex>
+typedef std::complex<float>			gr_complex;
+
+
+/*!
+ * \brief base class template for Numerically Controlled Oscillator (NCO)
+ */
+
+
+//FIXME  Eventually generalize this to fixed point
+
+template<class o_type, class i_type> 
+class ui_nco {
+public:
+  ui_nco () : phase (0), phase_inc(0) {}
+
+  virtual ~ui_nco () {}
+
+  // radians
+  void set_phase (double angle) {
+    phase = angle;
+  }
+
+  void adjust_phase (double delta_phase) {
+    phase += delta_phase;
+  }
+
+
+  // angle_rate is in radians / step
+  void set_freq (double angle_rate){
+    phase_inc = angle_rate;
+  }
+
+  // angle_rate is a delta in radians / step
+  void adjust_freq (double delta_angle_rate)
+  {
+    phase_inc += delta_angle_rate;
+  }
+
+  // increment current phase angle
+
+  void step () 
+  { 
+    phase += phase_inc; 
+    if (fabs (phase) > M_PI){
+      
+      while (phase > M_PI)
+	phase -= 2*M_PI;
+
+      while (phase < -M_PI)
+	phase += 2*M_PI;
+    }
+  }
+
+  void step (int n)
+  {
+    phase += phase_inc * n;
+    if (fabs (phase) > M_PI){
+      
+      while (phase > M_PI)
+	phase -= 2*M_PI;
+
+      while (phase < -M_PI)
+	phase += 2*M_PI;
+    }
+  }
+
+  // units are radians / step
+  double get_phase () const { return phase; }
+  double get_freq () const { return phase_inc; }
+
+  // compute sin and cos for current phase angle
+  void sincos (float *sinx, float *cosx) const;
+
+  // compute cos or sin for current phase angle
+  float cos () const { return std::cos (phase); }
+  float sin () const { return std::sin (phase); }
+
+  // compute a block at a time
+  void sin (float *output, int noutput_items, double ampl = 1.0);
+  void cos (float *output, int noutput_items, double ampl = 1.0);
+  void sincos (gr_complex *output, int noutput_items, double ampl = 1.0);
+  void sin (short *output, int noutput_items, double ampl = 1.0);
+  void cos (short *output, int noutput_items, double ampl = 1.0);
+  void sin (int *output, int noutput_items, double ampl = 1.0);
+  void cos (int *output, int noutput_items, double ampl = 1.0);
+
+protected:
+  double phase;
+  double phase_inc;
+};
+
+template<class o_type, class i_type> 
+void
+ui_nco<o_type,i_type>::sincos (float *sinx, float *cosx) const
+{
+  ui_sincosf (phase, sinx, cosx);
+}
+
+template<class o_type, class i_type> 
+void
+ui_nco<o_type,i_type>::sin (float *output, int noutput_items, double ampl)
+{
+  for (int i = 0; i < noutput_items; i++){
+    output[i] = (float)(sin () * ampl);
+    step ();
+  }
+}
+
+template<class o_type, class i_type> 
+void
+ui_nco<o_type,i_type>::cos (float *output, int noutput_items, double ampl)
+{
+  for (int i = 0; i < noutput_items; i++){
+    output[i] = (float)(cos () * ampl);
+    step ();
+  }
+}
+
+template<class o_type, class i_type> 
+void
+ui_nco<o_type,i_type>::sin (short *output, int noutput_items, double ampl)
+{
+  for (int i = 0; i < noutput_items; i++){
+    output[i] = (short)(sin() * ampl);
+    step ();
+  }
+}
+
+template<class o_type, class i_type> 
+void
+ui_nco<o_type,i_type>::cos (short *output, int noutput_items, double ampl)
+{
+  for (int i = 0; i < noutput_items; i++){
+    output[i] = (short)(cos () * ampl);
+    step ();
+  }
+}
+
+template<class o_type, class i_type> 
+void
+ui_nco<o_type,i_type>::sin (int *output, int noutput_items, double ampl)
+{
+  for (int i = 0; i < noutput_items; i++){
+    output[i] = (int)(sin () * ampl);
+    step ();
+  }
+}
+
+template<class o_type, class i_type> 
+void
+ui_nco<o_type,i_type>::cos (int *output, int noutput_items, double ampl)
+{
+  for (int i = 0; i < noutput_items; i++){
+    output[i] = (int)(cos () * ampl);
+    step ();
+  }
+}
+
+template<class o_type, class i_type> 
+void
+ui_nco<o_type,i_type>::sincos (gr_complex *output, int noutput_items, double ampl)
+{
+  for (int i = 0; i < noutput_items; i++){
+    float cosx, sinx;
+    sincos (&sinx, &cosx);
+    output[i] = gr_complex(cosx * ampl, sinx * ampl);
+    step ();
+  }
+}
+
+#endif /* INCLUDED_UI_NCO_H */
+
diff --git a/usrp/host/apps/ui_sincos.c b/usrp/host/apps/ui_sincos.c
new file mode 100644
index 000000000..36ca89c7d
--- /dev/null
+++ b/usrp/host/apps/ui_sincos.c
@@ -0,0 +1,81 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2004 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#define _GNU_SOURCE		// ask for GNU extensions if available
+
+#include <ui_sincos.h>
+#include <math.h>
+
+// ----------------------------------------------------------------
+
+#if defined (HAVE_SINCOS)
+
+void
+ui_sincos (double x, double *sinx, double *cosx)
+{
+  sincos (x, sinx, cosx);
+}
+
+#else
+
+void
+ui_sincos (double x, double *sinx, double *cosx)
+{
+  *sinx = sin (x);
+  *cosx = cos (x);
+}
+
+#endif
+
+// ----------------------------------------------------------------
+
+#if defined (HAVE_SINCOSF)
+
+void
+ui_sincosf (float x, float *sinx, float *cosx)
+{
+  sincosf (x, sinx, cosx);
+}
+
+#elif defined (HAVE_SINF) && defined (HAVE_COSF)
+
+void
+ui_sincosf (float x, float *sinx, float *cosx)
+{
+  *sinx = sinf (x);
+  *cosx = cosf (x);
+}
+
+#else
+
+void
+ui_sincosf (float x, float *sinx, float *cosx)
+{
+  *sinx = sin (x);
+  *cosx = cos (x);
+}
+
+#endif
diff --git a/usrp/host/apps/ui_sincos.h b/usrp/host/apps/ui_sincos.h
new file mode 100644
index 000000000..d2d6e4b76
--- /dev/null
+++ b/usrp/host/apps/ui_sincos.h
@@ -0,0 +1,39 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2002,2004 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef INCLUDED_UI_SINCOS_H
+#define INCLUDED_UI_SINCOS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  
+// compute sine and cosine at the same time
+
+void ui_sincos (double x, double *sin, double *cos);
+void ui_sincosf (float x, float *sin, float *cos);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* INCLUDED_UI_SINCOS_H */
diff --git a/usrp/host/lib/inband/Makefile.am b/usrp/host/lib/inband/Makefile.am
index 017c5c489..76e769fbe 100644
--- a/usrp/host/lib/inband/Makefile.am
+++ b/usrp/host/lib/inband/Makefile.am
@@ -22,46 +22,74 @@ include $(top_srcdir)/Makefile.common
 
 INCLUDES = 	\
 	$(DEFINES) $(OMNITHREAD_INCLUDES) $(PMT_INCLUDES) $(MBLOCK_INCLUDES) \
-	$(USRP_INCLUDES) $(BOOST_CFLAGS) $(CPPUNIT_INCLUDES)
+	$(USRP_INCLUDES) $(BOOST_CFLAGS) $(CPPUNIT_INCLUDES) \
+	-I$(srcdir)/../../apps
 
 TESTS = test_inband
 
 EXTRA_DIST =				\
-	usrp_server.mbh			
+	usrp_server.mbh			\
+	usrp_interface.mbh 
+
 
 lib_LTLIBRARIES = 			\
 	libusrp_inband.la		\
-	libusrp_inband-qa.la			
+	libusrp_inband-qa.la
 
 
 # ------------------------------------------------------------------------
 # Build the inband library
 
 BUILT_SOURCES =				\
-	usrp_server_mbh.cc
+	usrp_server_mbh.cc		\
+	usrp_interface_mbh.cc 
 
 usrp_server_mbh.cc : usrp_server.mbh
 	$(COMPILE_MBH) $(srcdir)/usrp_server.mbh usrp_server_mbh.cc
 
+usrp_interface_mbh.cc : usrp_interface.mbh
+	$(COMPILE_MBH) usrp_interface.mbh usrp_interface_mbh.cc
+
 libusrp_inband_la_SOURCES =		\
 	$(BUILT_SOURCES)		\
-	usrp_server.cc
+	../../apps/ui_sincos.c		\
+	usrp_inband_usb_packet.cc	\
+	usrp_rx.cc			\
+	usrp_rx_stub.cc			\
+	usrp_server.cc			\
+	usrp_tx.cc			\
+	usrp_tx_stub.cc			\
+	usrp_usb_interface.cc		
 
 libusrp_inband_la_LDFLAGS = $(NO_UNDEFINED) -version-info 0:0:0
 
 libusrp_inband_la_LIBADD =		\
 	$(MBLOCK_LA)			\
+	../legacy/libusrp.la  		\
 	-lstdc++
 
-
 include_HEADERS =			\
-	usrp_server.h			
+	usrp_inband_usb_packet.h 	\
+	usrp_rx.h			\
+	usrp_rx_stub.h			\
+	usrp_server.h			\
+	usrp_tx.h			\
+	usrp_tx_stub.h			\
+	usrp_usb_interface.h 		
 
 noinst_HEADERS =      			\
+	fake_usrp.h			\
 	qa_inband.h			\
 	qa_inband_packet_prims.h	\
 	qa_inband_usrp_server.h		\
-	usrp_inband_usb_packet.h	
+	symbols_usrp_channel.h		\
+	symbols_usrp_interface_cs.h	\
+	symbols_usrp_low_level_cs.h	\
+	symbols_usrp_rx.h		\
+	symbols_usrp_rx_cs.h		\
+	symbols_usrp_server_cs.h	\
+	symbols_usrp_tx.h		\
+	symbols_usrp_tx_cs.h		
 
 
 # ------------------------------------------------------------------------
@@ -79,17 +107,22 @@ libusrp_inband_qa_la_LDFLAGS = $(NO_UNDEFINED) -avoid-version
 libusrp_inband_qa_la_LIBADD =    	\
 	libusrp_inband.la		\
 	$(CPPUNIT_LIBS)			\
+	../legacy/libusrp.la		\
+	libusrp_inband.la		\
 	-lstdc++
 
 # ------------------------------------------------------------------------
 
 noinst_PROGRAMS =			\
-	test_inband
+	test_inband			\
+	test_usrp_inband
 
 test_inband_SOURCES = test_inband.cc
 test_inband_LDADD   = libusrp_inband-qa.la
 
+test_usrp_inband_SOURCES = test_usrp_inband.cc
+test_usrp_inband_LDADD = libusrp_inband-qa.la
+
 
 MOSTLYCLEANFILES = \
 	$(BUILT_SOURCES) *~ *.pyc
-
diff --git a/usrp/host/lib/inband/fake_usrp.cc b/usrp/host/lib/inband/fake_usrp.cc
new file mode 100644
index 000000000..8a66d5c18
--- /dev/null
+++ b/usrp/host/lib/inband/fake_usrp.cc
@@ -0,0 +1,135 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <fake_usrp.h>
+#include <iostream>
+#include <usrp_inband_usb_packet.h>
+#include <mb_class_registry.h>
+#include <vector>
+
+typedef usrp_inband_usb_packet transport_pkt;   // makes conversion to gigabit easy
+
+fake_usrp::fake_usrp()
+{
+  std::cout << "[fake_usrp] Initializing...\n";
+}
+
+fake_usrp::~fake_usrp() {}
+
+long
+fake_usrp::write_bus(transport_pkt *pkts, long n_bytes)
+{
+  std::cout << "[fake_usrp] Bytes over bus: " << n_bytes << "\n";
+
+  // I'm assuming that a control packet cannot exist in a burst of data packets,
+  // therefore i read only the first packet's channel in the current burst
+  if(pkts[0].chan() == 0x1f) {
+    return control_block(pkts, n_bytes);
+  } else {
+    return data_block(pkts, n_bytes);
+  }
+
+}
+
+long
+fake_usrp::data_block(transport_pkt *pkts, long n_bytes)
+{
+  std::cout << "[fake_usrp] Entering data block\n";
+
+  // Infer the number of packets from the byte count to do logical tests
+  long n_pkts = static_cast<long>(std::ceil(n_bytes / (double)transport_pkt::max_pkt_size()));
+  
+  std::cout << "[fake_usrp] Number of packets: " << n_pkts << "\n";
+
+  // The first packet should have the start of burst, and the last packet should have end of burst
+  if(pkts[0].start_of_burst() && pkts[n_pkts-1].end_of_burst()) {
+    std::cout << "[fake_usrp] Correct burst flags set\n";
+  } else {
+    std::cout << "[fake_usrp] Incorrect burst flags set!\n";
+    return 0;
+  }
+
+  // All other flags should be set to 0 (e.g., overrun should not be set yet) on ALL packets
+  for(int i=0; i < n_pkts; i++) {
+    if(pkts[i].overrun()) {
+      std::cout << "[fake_usrp] Incorrect set of overrun flag on transmit\n";
+      return 0;
+    } else if(pkts[i].underrun()) {
+      std::cout << "[fake_usrp] Incorrect set of underrun flag on transmit\n";
+      return 0;
+    } else if(pkts[i].dropped()) {
+      std::cout << "[fake_usrp] Incorrect set of drop flag on transmit\n";
+      return 0;
+    } 
+  }
+  std::cout << "[fake_usrp] Correct overrun, underrun, and drop flags on transmit (initialized to 0)\n";
+  
+  // The first packet should have a timestamp, other packets should have "NOW"
+  if(pkts[0].timestamp() != 0xffffffff) {
+    std::cout << "[fake_usrp] Correct timestamp on first packet\n";
+  } else {
+    std::cout << "[fake_usrp] Initial packet should not have the 0xffffffff timestamp\n";
+    return 0;
+  }
+
+  // Check that all of the other packets include the NOW timestamp
+  int check_stamps=1;
+  for(int i=1; i < n_pkts; i++)           // start at 1 to skip the first packet
+    if(pkts[i].timestamp() != 0xffffffff) 
+      check_stamps=0;
+
+  if(check_stamps) {
+    std::cout << "[fake_usrp] Correct NOW timestamps (0xffffffff) on intermediate burst packets\n";
+  } else {
+    std::cout << "[fake_usrp] Incorrect timestamps on intermediate burst packets\n";
+    return 0;
+  }
+
+  // Since we are being transparent about samples, we do not ensure the payload is correct, however
+  // it should be the case that if there are >1 packets, all packets except the last packet should
+  // have a full payload size
+  if(n_pkts > 1) {
+    int check_size=1;
+    for(int i=0; i < n_pkts-1; i++)
+      if(pkts[i].payload_len() != transport_pkt::max_payload())
+        check_size=0;
+
+    if(check_size) {
+      std::cout << "[fake_usrp] Correct payload size sanity check on packets\n";
+    } else {
+      std::cout << "[fake_usrp] Failed payload size sanity check\n";
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+long
+fake_usrp::control_block(transport_pkt *pkts, long n_bytes)
+{
+  std::cout << "[fake_usrp] Entering control block\n";
+
+  return 1;
+}
diff --git a/usrp/host/lib/inband/fake_usrp.h b/usrp/host/lib/inband/fake_usrp.h
new file mode 100644
index 000000000..818c5a506
--- /dev/null
+++ b/usrp/host/lib/inband/fake_usrp.h
@@ -0,0 +1,43 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_FAKE_USRP_H
+#define INCLUDED_FAKE_USRP_H
+
+#include <usrp_inband_usb_packet.h>
+typedef usrp_inband_usb_packet transport_pkt;
+
+/*!
+ * \brief Implements a fake USRP for testing without hardware
+ */
+class fake_usrp
+{
+ public:
+  fake_usrp();
+  ~fake_usrp();
+  long write_bus(transport_pkt *pkts, long n_bytes);
+
+ protected:
+  long data_block(transport_pkt *pkts, long n_bytes);
+  long control_block(transport_pkt *pkts, long n_bytes);
+};
+
+#endif /* INCLUDED_FAKE_USRP_H */
+
diff --git a/usrp/host/lib/inband/gen_test_packets.py b/usrp/host/lib/inband/gen_test_packets.py
index 1e22722d2..2ee646384 100755
--- a/usrp/host/lib/inband/gen_test_packets.py
+++ b/usrp/host/lib/inband/gen_test_packets.py
@@ -70,7 +70,7 @@ def gen_all_valid_packet_lengths_2_channels(output_file):
     lengths = gen_shuffled_lengths()
     npkts = len(lengths)                # number of packets we'll generator on each stream
     pkt_gen_0 = packet_sequence_generator(0, lengths)
-    pkt_gen_1 = packet_sequence_generator(1, gen_shuffled_lengths())
+    pkt_gen_1 = packet_sequence_generator(0x1f, gen_shuffled_lengths())
     pkt_gen = (pkt_gen_0, pkt_gen_1)
     
     which_gen = (npkts * [0]) + (npkts * [1])
@@ -83,5 +83,6 @@ def gen_all_valid_packet_lengths_2_channels(output_file):
     assert pkt_gen_1.next() == 16002    # 2*sum(1, 2, ..., 126) == 126 * 127
 
 if __name__ == '__main__':
+    random.seed(0)
     gen_all_valid_packet_lengths_1_channel(open("all_valid_packet_lengths_1_channel.dat", "w"))
     gen_all_valid_packet_lengths_2_channels(open("all_valid_packet_lengths_2_channels.dat", "w"))
diff --git a/usrp/host/lib/inband/qa_inband_usrp_server.cc b/usrp/host/lib/inband/qa_inband_usrp_server.cc
index 324d9ee11..b01e74e00 100644
--- a/usrp/host/lib/inband/qa_inband_usrp_server.cc
+++ b/usrp/host/lib/inband/qa_inband_usrp_server.cc
@@ -23,6 +23,7 @@
 #include <config.h>
 #endif
 
+#include <usrp_inband_usb_packet.h>
 #include <qa_inband_usrp_server.h>
 #include <cppunit/TestAssert.h>
 #include <stdio.h>
@@ -33,22 +34,17 @@
 #include <mb_class_registry.h>
 #include <vector>
 #include <iostream>
+#include <pmt.h>
 
-static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel");
-static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel");
-static pmt_t s_send_allocate_channel = pmt_intern("send-allocate-channel");
-static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel");
-static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel");
-static pmt_t s_send_deallocate_channel = pmt_intern("send-deallocate-channel");
-static pmt_t s_cmd_max_capacity = pmt_intern("cmd-max-capacity");
-static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity");
-static pmt_t s_cmd_ntx_chan  = pmt_intern("cmd-ntx-chan");
-static pmt_t s_cmd_nrx_chan  = pmt_intern("cmd-nrx-chan");
-static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan");
-static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan");
-static pmt_t s_cmd_current_capacity_allocation  = pmt_intern("cmd-current-capacity-allocation");
-static pmt_t s_response_current_capacity_allocation  = pmt_intern("response-current-capacity-allocation");
+#include <symbols_usrp_server_cs.h>
+#include <symbols_usrp_tx.h>
+#include <symbols_usrp_rx.h>
+#include <symbols_usrp_channel.h>
+#include <symbols_usrp_low_level_cs.h>
 
+typedef usrp_inband_usb_packet transport_pkt;   // makes conversion to gigabit easy
+
+static bool verbose = false;
 
 // ----------------------------------------------------------------------------------------------
 
@@ -82,16 +78,20 @@ qa_alloc_top::qa_alloc_top(mb_runtime *runtime, const std::string &instance_name
   : mb_mblock(runtime, instance_name, user_arg)
 { 
   d_nrecvd=0;
-  d_nmsgs_to_recv = 7;
+  d_nmsgs_to_recv = 6;
   d_nstatus=0;
-  d_nstatus_to_recv = 3;
+  d_nstatus_to_recv = 50;
   
   d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
   d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
   d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+ 
+  // Use the stub with the usrp_server
+  pmt_t usrp_server_dict = pmt_make_dict();
+  pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T);
 
   // Test the TX side
-  define_component("server", "usrp_server", PMT_F);
+  define_component("server", "usrp_server", usrp_server_dict);
   connect("self", "tx0", "server", "tx0");
   connect("self", "rx0", "server", "rx0");
   connect("self", "cs", "server", "cs");
@@ -103,42 +103,86 @@ qa_alloc_top::~qa_alloc_top(){}
 void
 qa_alloc_top::initial_transition()
 {
+  // Allocations should fail before open
+  d_tx->send(s_cmd_allocate_channel, 
+             pmt_list2(pmt_list2(s_response_allocate_channel, 
+                                 s_err_usrp_not_opened), 
+                       pmt_from_long(1)));
+
+  d_rx->send(s_cmd_allocate_channel, 
+             pmt_list2(pmt_list2(s_response_allocate_channel,
+                                 s_err_usrp_not_opened), 
+                       pmt_from_long(1)));
+
   // Retrieve information about the USRP, then run tests
-  d_cs->send(s_cmd_max_capacity, pmt_list1(PMT_F));
-  d_cs->send(s_cmd_ntx_chan, pmt_list1(PMT_F));
-  d_cs->send(s_cmd_nrx_chan, pmt_list1(PMT_F));
+  d_cs->send(s_cmd_open, 
+             pmt_list2(pmt_list2(s_response_open, PMT_T), 
+             pmt_from_long(0)));
+
+  d_cs->send(s_cmd_max_capacity, 
+             pmt_list1(pmt_list2(s_response_max_capacity, PMT_T)));
+  
+  d_cs->send(s_cmd_ntx_chan, 
+             pmt_list1(pmt_list2(s_response_ntx_chan, PMT_T)));
+  
+  d_cs->send(s_cmd_nrx_chan, 
+             pmt_list1(pmt_list2(s_response_nrx_chan,PMT_T)));
 }
 
 void
 qa_alloc_top::run_tests()
 {
-  std::cout << "[qa_alloc_top] Starting tests...\n";
+  if(verbose)
+    std::cout << "[qa_alloc_top] Starting tests...\n";
+
   // should be able to allocate 1 byte
-  d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1)));
+  d_tx->send(s_cmd_allocate_channel, 
+             pmt_list2(PMT_T, pmt_from_long(1)));
   
   // should not be able to allocate max capacity after 100 bytes were allocated
-  d_tx->send(s_cmd_allocate_channel, pmt_list2(pmt_from_long(usrp_server::RQSTD_CAPACITY_UNAVAIL), pmt_from_long(d_max_capacity)));  
+  d_tx->send(s_cmd_allocate_channel, 
+             pmt_list2(s_err_requested_capacity_unavailable, 
+                       pmt_from_long(d_max_capacity)));  
   
-  // keep allocating a little more until all of the channels are used and test the error response
-  // we start at 1 since we've already allocated 1 channel
+  // keep allocating a little more until all of the channels are used and test
+  // the error response we start at 1 since we've already allocated 1 channel
   for(int i=1; i < d_ntx_chan; i++) {
+
+    if(verbose)
+      std::cout << "[qa_alloc_top] Sent allocation request...\n";
+  
     d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1)));
+
     d_nmsgs_to_recv++;
   }
-  d_tx->send(s_cmd_allocate_channel, pmt_list2(pmt_from_long(usrp_server::CHANNEL_UNAVAIL), pmt_from_long(1)));
+
+  // No more channels after allocating all of them is expected
+  d_tx->send(s_cmd_allocate_channel, 
+             pmt_list2(s_err_channel_unavailable, 
+                       pmt_from_long(1)));
 
   // test out the same on the RX side
   d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1)));
-  d_rx->send(s_cmd_allocate_channel, pmt_list2(pmt_from_long(usrp_server::RQSTD_CAPACITY_UNAVAIL), pmt_from_long(d_max_capacity)));  
+
+  d_rx->send(s_cmd_allocate_channel, 
+             pmt_list2(s_err_requested_capacity_unavailable, 
+                       pmt_from_long(d_max_capacity)));  
 
   for(int i=1; i < d_nrx_chan; i++) {
+    
     d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1)));
+    
     d_nmsgs_to_recv++;
   }
-  d_rx->send(s_cmd_allocate_channel, pmt_list2(pmt_from_long(usrp_server::CHANNEL_UNAVAIL), pmt_from_long(1)));
 
-  // when all is said and done, there should be d_ntx_chan+d_ntx_chan bytes allocated
-  d_cs->send(s_cmd_current_capacity_allocation, pmt_list1(pmt_from_long(d_ntx_chan+d_nrx_chan)));
+  d_rx->send(s_cmd_allocate_channel, 
+             pmt_list2(s_err_channel_unavailable, 
+             pmt_from_long(1)));
+
+  // when all is said and done, there should be d_ntx_chan+d_ntx_chan bytes
+  // allocated
+  d_cs->send(s_cmd_current_capacity_allocation, 
+             pmt_list1(pmt_from_long(d_ntx_chan+d_nrx_chan)));
 }
 
 void
@@ -154,16 +198,22 @@ qa_alloc_top::handle_message(mb_message_sptr msg)
   if (pmt_eq(msg->port_id(), d_cs->port_symbol())) {
       
     if(pmt_eq(msg->signal(), s_response_max_capacity)) {
-      d_max_capacity = pmt_to_long(pmt_nth(1, data));
-      std::cout << "[qa_alloc_top] USRP has max capacity of " << d_max_capacity << "\n";
+      d_max_capacity = pmt_to_long(pmt_nth(2, data));
+      if(verbose)
+        std::cout << "[qa_alloc_top] USRP has max capacity of " 
+                  << d_max_capacity << "\n";
     }
     else if(pmt_eq(msg->signal(), s_response_ntx_chan)) {
-      d_ntx_chan = pmt_to_long(pmt_nth(1, data));
-      std::cout << "[qa_alloc_top] USRP tx channels: " << d_ntx_chan << "\n";
+      d_ntx_chan = pmt_to_long(pmt_nth(2, data));
+      if(verbose)
+        std::cout << "[qa_alloc_top] USRP tx channels: " 
+                  << d_ntx_chan << "\n";
     }
     else if(pmt_eq(msg->signal(), s_response_nrx_chan)) {
-      d_nrx_chan = pmt_to_long(pmt_nth(1, data));
-      std::cout << "[qa_alloc_top] USRP rx channels: " << d_nrx_chan << "\n";
+      d_nrx_chan = pmt_to_long(pmt_nth(2, data));
+      if(verbose)
+        std::cout << "[qa_alloc_top] USRP rx channels: " 
+                  << d_nrx_chan << "\n";
     }
     else if(pmt_eq(msg->signal(), s_response_current_capacity_allocation)) {
       check_message(msg);
@@ -171,6 +221,8 @@ qa_alloc_top::handle_message(mb_message_sptr msg)
     
     d_nstatus++;
 
+    check_message(msg);
+
     if(d_nstatus==d_nstatus_to_recv)
       run_tests();
   }
@@ -180,18 +232,26 @@ void
 qa_alloc_top::check_message(mb_message_sptr msg)
 {
   pmt_t data = msg->data();
+  pmt_t event = msg->signal();
+
+  pmt_t expected = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
 
-  pmt_t expected_result = pmt_nth(0, data);
-  pmt_t result = pmt_nth(1, data);
+  pmt_t e_event = pmt_nth(0, expected);
+  pmt_t e_status = pmt_nth(1, expected);
   
   d_nrecvd++;
 
 
-  if(!pmt_eqv(expected_result, result)) {
-    std::cout << "Got: " << result << " Expected: " << expected_result << "\n";
+  if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) {
+    if(verbose)
+      std::cout << "Got: " << status << " Expected: " << e_status << "\n";
     shutdown_all(PMT_F);
+    return;
   } else {
-    std::cout << "[qa_alloc_top] Received expected response for message " << d_nrecvd << "\n";
+    if(verbose)
+      std::cout << "[qa_alloc_top] Received expected response for message " 
+                << d_nrecvd << " (" << event << ")\n";
   }
 
   if(d_nrecvd == d_nmsgs_to_recv)
@@ -242,16 +302,20 @@ qa_dealloc_top::qa_dealloc_top(mb_runtime *runtime, const std::string &instance_
   d_ndealloc_recvd=0;
   d_ndealloc_to_recv = 0;
   d_nalloc_recvd=0;
-  d_nalloc_to_recv = 0;
+  d_nalloc_to_recv = 0;   // auto-set
   d_nstatus=0;
-  d_nstatus_to_recv = 3;
+  d_nstatus_to_recv = 4;
   
   d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
   d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
   d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
 
+  // Use the stub with the usrp_server
+  pmt_t usrp_server_dict = pmt_make_dict();
+  pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T);
+
   // Test the TX side
-  define_component("server", "usrp_server", PMT_F);
+  define_component("server", "usrp_server", usrp_server_dict);
   connect("self", "tx0", "server", "tx0");
   connect("self", "rx0", "server", "rx0");
   connect("self", "cs", "server", "cs");
@@ -262,26 +326,46 @@ qa_dealloc_top::~qa_dealloc_top(){}
 void
 qa_dealloc_top::initial_transition()
 {
+
+  if(verbose)
+    std::cout << "[qa_dealloc_top] Initializing...\n";
+
   // Retrieve information about the USRP, then run tests
-  d_cs->send(s_cmd_max_capacity, pmt_list1(PMT_F));
-  d_cs->send(s_cmd_ntx_chan, pmt_list1(PMT_F));
-  d_cs->send(s_cmd_nrx_chan, pmt_list1(PMT_F));
+  d_cs->send(s_cmd_open, 
+             pmt_list2(pmt_list2(s_response_open,PMT_T), 
+             pmt_from_long(0)));
+
+  d_cs->send(s_cmd_max_capacity, 
+             pmt_list1(pmt_list2(s_response_max_capacity,PMT_T)));
+
+  d_cs->send(s_cmd_ntx_chan, 
+             pmt_list1(pmt_list2(s_response_ntx_chan,PMT_T)));
+
+  d_cs->send(s_cmd_nrx_chan, 
+             pmt_list1(pmt_list2(s_response_nrx_chan,PMT_T)));
 }
 
 void
 qa_dealloc_top::allocate_max()
 {
-  std::cout << "[qa_dealloc_top] Max allocating...\n";
 
   // Keep allocating until we hit the maximum number of channels
   for(int i=0; i < d_ntx_chan; i++) {
-    d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1)));
+    d_tx->send(s_cmd_allocate_channel, 
+               pmt_list2(pmt_list2(s_response_allocate_channel,PMT_T),
+               pmt_from_long(1)));  // 1 byte is good enough
+
     d_nalloc_to_recv++;
   }
+
   for(int i=0; i < d_nrx_chan; i++) {
-    d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1)));
+    d_rx->send(s_cmd_allocate_channel, 
+               pmt_list2(pmt_list2(s_response_allocate_channel,PMT_T), 
+               pmt_from_long(1)));
+
     d_nalloc_to_recv++;
   }
+
 }
 
 void
@@ -289,40 +373,103 @@ qa_dealloc_top::deallocate_all() {
   
   // Deallocate all of the channels that were allocated from allocate_max()
   for(int i=0; i < (int)d_tx_chans.size(); i++) {
-    d_tx->send(s_cmd_deallocate_channel, pmt_list2(PMT_T, pmt_from_long(d_tx_chans[i])));
+
+    if(verbose)
+      std::cout << "[qa_dealloc_top] Trying to dealloc TX " 
+                << d_tx_chans[i] << std::endl;
+
+    d_tx->send(s_cmd_deallocate_channel, 
+               pmt_list2(pmt_list2(s_response_deallocate_channel,PMT_T), 
+               pmt_from_long(d_tx_chans[i])));
+
     d_ndealloc_to_recv++;
   }
+
+  // Deallocate the RX side now
   for(int i=0; i < (int)d_rx_chans.size(); i++) {
-    d_rx->send(s_cmd_deallocate_channel, pmt_list2(PMT_T, pmt_from_long(d_rx_chans[i])));
+
+    if(verbose)
+      std::cout << "[qa_dealloc_top] Trying to dealloc RX " 
+                << d_tx_chans[i] << std::endl;
+
+    d_rx->send(s_cmd_deallocate_channel, 
+               pmt_list2(pmt_list2(s_response_deallocate_channel,PMT_T), 
+               pmt_from_long(d_rx_chans[i])));
+
     d_ndealloc_to_recv++;
   }
 
-  // Should get permission denied errors trying to re-dealloc the channels, as we no
-  // longer have permission to them after deallocating
+  // Should get permission denied errors trying to re-dealloc the channels, as
+  // we no longer have permission to them after deallocating
   for(int i=0; i < (int)d_tx_chans.size(); i++) {
-    d_tx->send(s_cmd_deallocate_channel, pmt_list2(pmt_from_long(usrp_server::PERMISSION_DENIED), pmt_from_long(d_tx_chans[i])));
+
+    d_tx->send(s_cmd_deallocate_channel, 
+               pmt_list2(pmt_list2(s_response_deallocate_channel,
+                             s_err_channel_permission_denied), 
+                         pmt_from_long(d_tx_chans[i])));
+
     d_ndealloc_to_recv++;
   }
+
+  // Same for RX
   for(int i=0; i < (int)d_rx_chans.size(); i++) {
-    d_rx->send(s_cmd_deallocate_channel, pmt_list2(pmt_from_long(usrp_server::PERMISSION_DENIED), pmt_from_long(d_rx_chans[i])));
+
+    d_rx->send(s_cmd_deallocate_channel, 
+               pmt_list2(pmt_list2(s_response_deallocate_channel,
+                             s_err_channel_permission_denied), 
+                         pmt_from_long(d_rx_chans[i])));
+  
     d_ndealloc_to_recv++;
   }
 
-  // Try to deallocate a channel that doesn't exist on both sides, the last element in the vectors
-  // is the highest channel number, so we take that plus 1
+  // Try to deallocate a channel that doesn't exist on both sides, the last
+  // element in the vectors is the highest channel number, so we take that plus
+  // 1
   d_ndealloc_to_recv+=2;
-  d_tx->send(s_cmd_deallocate_channel, pmt_list2(pmt_from_long(usrp_server::CHANNEL_INVALID), pmt_from_long(d_rx_chans.back()+1)));
-  d_rx->send(s_cmd_deallocate_channel, pmt_list2(pmt_from_long(usrp_server::CHANNEL_INVALID), pmt_from_long(d_rx_chans.back()+1)));
+  d_tx->send(s_cmd_deallocate_channel, 
+             pmt_list2(pmt_list2(s_response_deallocate_channel,
+                                 s_err_channel_invalid), 
+                       pmt_from_long(d_rx_chans.back()+1)));
+
+  d_rx->send(s_cmd_deallocate_channel, 
+             pmt_list2(pmt_list2(s_response_deallocate_channel,
+                                 s_err_channel_invalid), 
+                       pmt_from_long(d_rx_chans.back()+1)));
 
 
   // The used capacity should be back to 0 now that we've deallocated everything
-  d_cs->send(s_cmd_current_capacity_allocation, pmt_list1(pmt_from_long(0)));
+  d_cs->send(s_cmd_current_capacity_allocation,
+             pmt_list1(pmt_list2(s_response_current_capacity_allocation,
+                                 PMT_T)));
 }
 
 void
 qa_dealloc_top::handle_message(mb_message_sptr msg)
 {
   pmt_t data = msg->data();
+  pmt_t event = msg->signal();
+  
+  if(pmt_eq(event, pmt_intern("%shutdown")))
+    return;
+
+  pmt_t expected = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+
+  pmt_t e_event = pmt_nth(0, expected);
+  pmt_t e_status = pmt_nth(1, expected);
+
+  if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) {
+    if(verbose)
+      std::cout << "Got: " << status << " Expected: " << e_status << "\n";
+    shutdown_all(PMT_F);
+    return;
+  } else {
+    if(verbose)
+      std::cout << "[qa_alloc_top] Received expected response for message " 
+                << d_ndealloc_recvd
+      << " (" << event << ")\n";
+  }
+
   if (pmt_eq(msg->port_id(), d_tx->port_symbol())
        || pmt_eq(msg->port_id(), d_rx->port_symbol())) {
     
@@ -330,34 +477,32 @@ qa_dealloc_top::handle_message(mb_message_sptr msg)
       check_allocation(msg);
     }
     
-    if(pmt_eq(msg->signal(), s_response_deallocate_channel)){
-      check_deallocation(msg);
-    }
   }
   
   if (pmt_eq(msg->port_id(), d_cs->port_symbol())) {
       
     if(pmt_eq(msg->signal(), s_response_max_capacity)) {
-      d_max_capacity = pmt_to_long(pmt_nth(1, data));
-      std::cout << "[qa_dealloc_top] USRP has max capacity of " << d_max_capacity << "\n";
+      d_max_capacity = pmt_to_long(pmt_nth(2, data));
     }
     else if(pmt_eq(msg->signal(), s_response_ntx_chan)) {
-      d_ntx_chan = pmt_to_long(pmt_nth(1, data));
-      std::cout << "[qa_dealloc_top] USRP tx channels: " << d_ntx_chan << "\n";
+      d_ntx_chan = pmt_to_long(pmt_nth(2, data));
     }
     else if(pmt_eq(msg->signal(), s_response_nrx_chan)) {
-      d_nrx_chan = pmt_to_long(pmt_nth(1, data));
-      std::cout << "[qa_dealloc_top] USRP rx channels: " << d_nrx_chan << "\n";
+      d_nrx_chan = pmt_to_long(pmt_nth(2, data));
     }
     else if(pmt_eq(msg->signal(), s_response_current_capacity_allocation)) {
-      // the final command is a capacity check which should be 0, then we shutdown
-      pmt_t expected_result = pmt_nth(0, data);
-      pmt_t result = pmt_nth(1, data);
+      // the final command is a capacity check which should be 0, then we
+      // shutdown
+      pmt_t expected_result = pmt_from_long(0);
+      pmt_t result = pmt_nth(2, data);
 
-      if(pmt_eqv(expected_result, result))
+      if(pmt_eqv(expected_result, result)) {
         shutdown_all(PMT_T);
-      else
+        return;
+      } else {
         shutdown_all(PMT_F);
+        return;
+      }
     }
     
     d_nstatus++;
@@ -367,72 +512,833 @@ qa_dealloc_top::handle_message(mb_message_sptr msg)
   }
 }
 
+
 void
-qa_dealloc_top::check_deallocation(mb_message_sptr msg)
+qa_dealloc_top::check_allocation(mb_message_sptr msg)
 {
   pmt_t data = msg->data();
+  pmt_t event = msg->signal();
 
-  pmt_t expected_result = pmt_nth(0, data);
-  pmt_t result = pmt_nth(1, data);
+  pmt_t expected = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+  pmt_t channel = pmt_nth(2, data);
 
-  d_ndealloc_recvd++;
+  d_nalloc_recvd++;
 
-  if(!pmt_eqv(expected_result, result)) {
-    std::cout << "Got: " << result << " Expected: " << expected_result << "\n";
+  if(!pmt_eqv(status, PMT_T)) {
     shutdown_all(PMT_F);
+    return;
   } else {
-    std::cout << "[qa_dealloc_top] Received expected deallocation response for message " << d_ndealloc_recvd << "\n";
+    // store all of the allocate channel numbers
+    if(pmt_eq(msg->port_id(), d_tx->port_symbol()))
+      d_tx_chans.push_back(pmt_to_long(channel));
+    if(pmt_eq(msg->port_id(), d_rx->port_symbol()))
+      d_rx_chans.push_back(pmt_to_long(channel));
   }
+
+  if(d_nalloc_recvd == d_nalloc_to_recv) {
+
+    if(verbose) {
+      std::cout << "[qa_dealloc_top] Allocated TX channels: ";
+      for(int i=0; i < (int)d_tx_chans.size(); i++)
+        std::cout << d_tx_chans[i] << " ";
+
+      std::cout << "\n[qa_dealloc_top] Allocated RX channels: ";
+      for(int i=0; i < (int)d_rx_chans.size(); i++)
+        std::cout << d_rx_chans[i] << " ";
+      std::cout << "\n";
+    }
+
+    deallocate_all();   // once we've allocated all of our channels, try to
+                        // dealloc them
+  }
+}
+
+REGISTER_MBLOCK_CLASS(qa_dealloc_top);
+
+// ----------------------------------------------------------------------------------------------
+
+class qa_open_close_top : public mb_mblock
+{
+  mb_port_sptr d_cs;
+  
+  long d_max_capacity;
+
+  long d_nmsg_to_recv;
+  long d_nmsg_recvd;
+
+ public:
+  qa_open_close_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~qa_open_close_top();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void check_cs(mb_message_sptr msg);
+  void run_tests();
+};
+
+qa_open_close_top::qa_open_close_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg)
+{ 
+
+  d_nmsg_to_recv=7;
+  d_nmsg_recvd=0;
+  
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+
+  // Use the stub with the usrp_server
+  pmt_t usrp_server_dict = pmt_make_dict();
+  pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T);
+
+  // Test the TX side
+  define_component("server", "usrp_server", usrp_server_dict);
+  connect("self", "cs", "server", "cs");
 }
 
+qa_open_close_top::~qa_open_close_top(){}
+
 void
-qa_dealloc_top::check_allocation(mb_message_sptr msg)
+qa_open_close_top::initial_transition()
+{
+  run_tests();
+}
+
+void
+qa_open_close_top::run_tests()
+{
+  // std::cout << "[qa_open_close_top] Starting tests\n";
+
+  // A close before an open should fail
+  d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close, 
+                                              s_err_usrp_already_closed)));
+  
+  // Perform an open, and a second open which should fail
+  d_cs->send(s_cmd_open, 
+             pmt_list2(pmt_list2(s_response_open,PMT_T), 
+                       pmt_from_long(0)));
+
+  d_cs->send(s_cmd_open, 
+             pmt_list2(pmt_list2(s_response_open,
+                                 s_err_usrp_already_opened), 
+                       pmt_from_long(0)));
+
+  // A close should now be successful since the interface is open
+  d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T)));
+
+  // But, a second close should fail
+  d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,
+                                              s_err_usrp_already_closed)));
+  
+  // Just to be thorough, try an open and close again
+  d_cs->send(s_cmd_open, 
+             pmt_list2(pmt_list2(s_response_open,PMT_T), 
+                       pmt_from_long(0)));
+
+  d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T)));
+  
+}
+
+
+void
+qa_open_close_top::handle_message(mb_message_sptr msg)
 {
   pmt_t data = msg->data();
 
-  pmt_t invocation_handle = pmt_nth(0, data);
+  if (pmt_eq(msg->port_id(), d_cs->port_symbol())) {
+      check_cs(msg);
+  }
+
+  d_nmsg_recvd++;
+
+  if(d_nmsg_to_recv == d_nmsg_recvd)
+    shutdown_all(PMT_T);
+}
+
+void
+qa_open_close_top::check_cs(mb_message_sptr msg)
+{
+  pmt_t data = msg->data();
+  pmt_t event = msg->signal();
+
+  pmt_t expected = pmt_nth(0, data);
   pmt_t status = pmt_nth(1, data);
-  pmt_t channel = pmt_nth(2, data);
+
+  pmt_t e_event = pmt_nth(0, expected);
+  pmt_t e_status = pmt_nth(1, expected);
+
+  if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) {
+
+    if(verbose)
+      std::cout << "[qa_open_close_top] FAILED check_cs... Got: " << status
+                << " Expected: " << e_status
+                << " for event " << event << "\n";
+
+    shutdown_all(PMT_F);
+  } else {
+    if(verbose)
+      std::cout << "[qa_open_close_top] Received expected CS response (" 
+                << event << ")\n";
+  }
+
+}
+
+REGISTER_MBLOCK_CLASS(qa_open_close_top);
+
+// ----------------------------------------------------------------------------------------------
+
+class qa_tx_top : public mb_mblock
+{
+  mb_port_sptr d_tx;
+  mb_port_sptr d_rx;
+  mb_port_sptr d_cs;
   
-  d_nalloc_recvd++;
+  long d_max_capacity;
+  long d_ntx_chan, d_nrx_chan;
+
+  long d_tx_chan;
+  long d_rx_chan;
+
+  long d_nmsg_to_recv;
+  long d_nmsg_recvd;
+
+ public:
+  qa_tx_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~qa_tx_top();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void check_allocation(mb_message_sptr msg);
+  void check_deallocation(mb_message_sptr msg);
+  void check_xmit(mb_message_sptr msg);
+  void check_cs(mb_message_sptr msg);
+  void run_tests();
+};
 
-  if(pmt_eqv(status, PMT_F)) {
-    std::cout << "[qa_dealloc_top] Unexpected error response when allocating channels\n";
+qa_tx_top::qa_tx_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg)
+{ 
+
+  d_nmsg_to_recv=10;
+  d_nmsg_recvd=0;
+  
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+
+  // Use the stub with the usrp_server
+  pmt_t usrp_server_dict = pmt_make_dict();
+  pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T);
+
+  // Test the TX side
+  define_component("server", "usrp_server", usrp_server_dict);
+  connect("self", "tx0", "server", "tx0");
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+}
+
+qa_tx_top::~qa_tx_top(){}
+
+void
+qa_tx_top::initial_transition()
+{
+  run_tests();
+}
+
+void
+qa_tx_top::run_tests()
+{
+  if(verbose)
+   std::cout << "[qa_tx_top] Starting tests\n";
+
+  // A transmit before an open should fail
+  d_tx->send(s_cmd_xmit_raw_frame, 
+             pmt_list4(pmt_list2(s_response_xmit_raw_frame, 
+                                 s_err_usrp_not_opened), 
+                       pmt_from_long(0), 
+                       pmt_make_u32vector(transport_pkt::max_payload()/4, 0),
+                       pmt_from_long(0)));
+  
+  // Now open
+  d_cs->send(s_cmd_open, 
+             pmt_list2(pmt_list2(s_response_open,PMT_T), 
+                       pmt_from_long(0)));
+
+  // Try to transmit on a channel that we have no allocation for
+  d_tx->send(s_cmd_xmit_raw_frame, 
+             pmt_list4(pmt_list2(s_response_xmit_raw_frame,
+                                 s_err_channel_permission_denied), 
+                       pmt_from_long(0), 
+                       pmt_make_u32vector(transport_pkt::max_payload()/4, 0), 
+                       pmt_from_long(0)));
+
+  // Get a channel allocation and send on it, we assume 0 (FIXME) until 'defer'
+  // is implemented for simplicity
+  d_tx->send(s_cmd_allocate_channel, 
+             pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), 
+                       pmt_from_long(1)));
+
+  d_tx->send(s_cmd_xmit_raw_frame, 
+             pmt_list4(pmt_list2(s_response_xmit_raw_frame, PMT_T), 
+                       pmt_from_long(0), 
+                       pmt_make_u32vector(transport_pkt::max_payload()/4, 0), 
+                       pmt_from_long(0)));
+
+  // Close should be successful
+  d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T)));
+
+  // After closing, a new transmit raw frame should fail again
+  d_tx->send(s_cmd_xmit_raw_frame, 
+             pmt_list4(pmt_list2(s_response_xmit_raw_frame, 
+                                 s_err_usrp_not_opened), 
+                       pmt_from_long(0), 
+                       pmt_make_u32vector(transport_pkt::max_payload()/4, 0), 
+                       pmt_from_long(0)));
+
+  // Reopen and retry before getting an allocation, the first xmit should fail,
+  // after we allocate it should work again
+  d_cs->send(s_cmd_open, 
+             pmt_list2(pmt_list2(s_response_open, PMT_T), 
+                       pmt_from_long(0)));
+
+  d_tx->send(s_cmd_xmit_raw_frame, 
+             pmt_list4(pmt_list2(s_response_xmit_raw_frame,
+                                 s_err_channel_permission_denied), 
+                       pmt_from_long(0), 
+                       pmt_make_u32vector(transport_pkt::max_payload()/4, 0), 
+                       pmt_from_long(0)));
+
+  d_tx->send(s_cmd_allocate_channel, 
+             pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), 
+                       pmt_from_long(1)));
+
+  d_tx->send(s_cmd_xmit_raw_frame, 
+             pmt_list4(pmt_list2(s_response_xmit_raw_frame,PMT_T), 
+                       pmt_from_long(0), 
+                       pmt_make_u32vector(transport_pkt::max_payload()/4, 0), 
+                       pmt_from_long(0)));
+
+  // A final close which should be successful
+  d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T)));
+  
+}
+
+
+void
+qa_tx_top::handle_message(mb_message_sptr msg)
+{
+  pmt_t data = msg->data();
+  pmt_t event = msg->signal();
+  
+  if(pmt_eq(event, pmt_intern("%shutdown")))
+    return;
+
+  pmt_t expected = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+
+  pmt_t e_event = pmt_nth(0, expected);
+  pmt_t e_status = pmt_nth(1, expected);
+
+  if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) {
+    if(verbose)
+      std::cout << "[qa_xmit_top] Got: " << status 
+                << " Expected: " << e_status 
+                << "For signal: " << event << "\n";
     shutdown_all(PMT_F);
+    return;
   } else {
+    if(verbose)
+      std::cout << "[qa_xmit_top] Received expected response for message " 
+                << d_nmsg_recvd
+      << " (" << event << ")\n";
+  }
+
+  if (pmt_eq(msg->port_id(), d_tx->port_symbol())
+       || pmt_eq(msg->port_id(), d_rx->port_symbol())) {
+    
+    if(pmt_eq(msg->signal(), s_response_allocate_channel)) 
+      check_allocation(msg);
+    
+  }
+  
+  d_nmsg_recvd++;
+
+  if(d_nmsg_to_recv == d_nmsg_recvd){
+    shutdown_all(PMT_T);
+    return;
+  }
+}
+
+void
+qa_tx_top::check_allocation(mb_message_sptr msg)
+{
+  pmt_t data = msg->data();
+  pmt_t event = msg->signal();
+  
+  pmt_t expected = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+  pmt_t channel = pmt_nth(2, data);
+
+  if(pmt_eqv(status, PMT_T)) {
     // store all of the allocate channel numbers
     if(pmt_eq(msg->port_id(), d_tx->port_symbol()))
-      d_tx_chans.push_back(pmt_to_long(channel));
+      d_tx_chan = pmt_to_long(channel);
     if(pmt_eq(msg->port_id(), d_rx->port_symbol()))
-      d_rx_chans.push_back(pmt_to_long(channel));
+      d_rx_chan = pmt_to_long(channel);
   }
+}
 
-  if(d_nalloc_recvd == d_nalloc_to_recv) {
+REGISTER_MBLOCK_CLASS(qa_tx_top);
+
+// ----------------------------------------------------------------------------------------------
+
+class qa_rx_top : public mb_mblock
+{
+  mb_port_sptr d_rx;
+  mb_port_sptr d_cs;
+  
+  long d_max_capacity;
+  long d_ntx_chan, d_nrx_chan;
+
+  long d_rx_chan;
+
+  long d_got_response_recv;
+
+  long d_nmsg_to_recv;
+  long d_nmsg_recvd;
+
+ public:
+  qa_rx_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~qa_rx_top();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void check_allocation(mb_message_sptr msg);
+  void check_deallocation(mb_message_sptr msg);
+  void check_xmit(mb_message_sptr msg);
+  void check_cs(mb_message_sptr msg);
+  void run_tests();
+};
+
+qa_rx_top::qa_rx_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg),
+    d_got_response_recv(false)
+{ 
+
+  d_nmsg_to_recv=12;
+  d_nmsg_recvd=0;
+  
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+
+  // Use the stub with the usrp_server
+  pmt_t usrp_server_dict = pmt_make_dict();
+  pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"), PMT_T);
+
+  // Test the TX side
+  define_component("server", "usrp_server", usrp_server_dict);
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+}
+
+qa_rx_top::~qa_rx_top(){}
+
+void
+qa_rx_top::initial_transition()
+{
+  run_tests();
+}
+
+void
+qa_rx_top::run_tests()
+{
+  if(verbose)
+    std::cout << "[qa_rx_top] Starting tests\n";
+
+  d_cs->send(s_cmd_open, pmt_list2(pmt_list2(s_response_open,PMT_T), pmt_from_long(0)));
+
+  d_rx->send(s_cmd_allocate_channel, 
+             pmt_list2(pmt_list2(s_response_allocate_channel,PMT_T), 
+             pmt_from_long(1)));
+
+  d_rx->send(s_cmd_start_recv_raw_samples, 
+             pmt_list2(PMT_NIL, 
+                       pmt_from_long(0)));
+
+  // A small sleep is used to ensure, if working properly, a recv
+  // response comes through successfully before the close gets
+  // through
+  usleep(1000);
+
+  d_rx->send(s_cmd_stop_recv_raw_samples, 
+             pmt_list2(PMT_NIL, 
+                       pmt_from_long(0)));
+
+  d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T)));
+  
+}
+
+
+void
+qa_rx_top::handle_message(mb_message_sptr msg)
+{
+  pmt_t data = msg->data();
+  pmt_t event = msg->signal();
+  
+  if(pmt_eq(event, pmt_intern("%shutdown")))
+    return;
+  
+  pmt_t expected = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+  
+  // For testing RX, an invocation handle is not generated by the stub,
+  // therefore the same approach for testing is not used.  We simply
+  // expect all responses to be true.
+  if(pmt_eq(event, s_response_recv_raw_samples)) {
+    if(!pmt_eqv(status, PMT_T)) {
+      if(verbose)
+        std::cout << "Got: " << status << " Expected: " << PMT_T << "\n";
+      shutdown_all(PMT_F);
+      return;
+    }
+    else {
+      if(verbose)
+        std::cout << "[qa_rx_top] Received expected response for message " 
+                  << d_nmsg_recvd
+                  << " (" << event << ")\n";
+
+      // All we want is 1 response receive!  Can't guarantee exact numbers
+      d_got_response_recv = true;
+    }
+    return;
+  }
+
+  pmt_t e_event = pmt_nth(0, expected);
+  pmt_t e_status = pmt_nth(1, expected);
+
+  if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) {
+   if(verbose)
+      std::cout << "Got: " << status << " Expected: " << e_status << "\n";
+    shutdown_all(PMT_F);
+    return;
+  } else {
+    if(verbose)
+      std::cout << "[qa_rx_top] Received expected response for message " 
+                << d_nmsg_recvd
+      << " (" << event << ")\n";
+  }
+
+  if (pmt_eq(msg->port_id(), d_rx->port_symbol())) {
+    
+    if(pmt_eq(msg->signal(), s_response_allocate_channel)) 
+      check_allocation(msg);
+
+  }
+
+  // We stop when we get a close, we are successful if we
+  // got a response from recv, fail if we never got a recv response
+  if(pmt_eq(msg->signal(), s_response_close)) {
     
-    std::cout << "[qa_dealloc_top] Allocated TX channels: ";
-    for(int i=0; i < (int)d_tx_chans.size(); i++)
-      std::cout << d_tx_chans[i] << " ";
+    if(d_got_response_recv) {
+      shutdown_all(PMT_T);
+      return;
+    }
+    else {
+      shutdown_all(PMT_F);
+      if(verbose)
+        std::cout << "[qa_rx_top] No response message before close\n";
+      return;
+    }
+
+  }
+    
+  
+  d_nmsg_recvd++;
+
+}
 
-    std::cout << "\n[qa_dealloc_top] Allocated RX channels: ";
-    for(int i=0; i < (int)d_rx_chans.size(); i++)
-      std::cout << d_rx_chans[i] << " ";
-    std::cout << "\n";
 
-    deallocate_all();   // once we've allocated all of our channels, try to dealloc them
+void
+qa_rx_top::check_allocation(mb_message_sptr msg)
+{
+  pmt_t data = msg->data();
+  pmt_t event = msg->signal();
+  
+  pmt_t expected = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+  pmt_t channel = pmt_nth(2, data);
+
+  if(pmt_eqv(status, PMT_T)) {
+    // store all of the allocate channel numbers
+    if(pmt_eq(msg->port_id(), d_rx->port_symbol()))
+      d_rx_chan = pmt_to_long(channel);
   }
 }
 
-REGISTER_MBLOCK_CLASS(qa_dealloc_top);
+REGISTER_MBLOCK_CLASS(qa_rx_top);
+
+
+// ----------------------------------------------------------------------------------------------
+
+class qa_cs_top : public mb_mblock
+{
+  mb_port_sptr d_tx;
+  mb_port_sptr d_rx;
+  mb_port_sptr d_cs;
+
+  long d_nmsgs_to_recv;
+  long d_nrecvd;
+
+  long d_max_capacity;
+  long d_ntx_chan, d_nrx_chan;
+
+  long d_nstatus;
+  long d_nstatus_to_recv;
+
+ public:
+  qa_cs_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~qa_cs_top();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void check_message(mb_message_sptr msg);
+  void run_tests();
+};
+
+qa_cs_top::qa_cs_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg)
+{ 
+  d_nrecvd=0;
+  d_nmsgs_to_recv = 8;
+  d_nstatus=0;
+  d_nstatus_to_recv = 50;
+  
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+ 
+  // Use the stub with the usrp_server
+  pmt_t usrp_server_dict = pmt_make_dict();
+  pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T);
+
+  // Test the TX side
+  define_component("server", "usrp_server", usrp_server_dict);
+  connect("self", "tx0", "server", "tx0");
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+
+}
+
+qa_cs_top::~qa_cs_top(){}
+
+void
+qa_cs_top::initial_transition()
+{
+  run_tests();
+}
+
+void
+qa_cs_top::run_tests()
+{
+  if(verbose)
+    std::cout << "[qa_cs_top] Starting tests...\n";
+  
+  // Retrieve information about the USRP, then run tests
+  d_cs->send(s_cmd_open, 
+             pmt_list2(pmt_list2(s_response_open, PMT_T), 
+             pmt_from_long(0)));
+
+  // should be able to allocate 1 byte
+  d_tx->send(s_cmd_allocate_channel, 
+             pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), 
+                       pmt_from_long(1)));
+  
+  d_rx->send(s_cmd_allocate_channel, 
+             pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), 
+                       pmt_from_long(1)));
+  
+  // Need to start receiving to read from the USRP to get C/S responses
+  d_rx->send(s_cmd_start_recv_raw_samples, 
+             pmt_list2(PMT_NIL, 
+                       pmt_from_long(0)));
+
+  d_tx->send(s_cmd_to_control_channel,
+             pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T),
+                       pmt_list1(
+                            pmt_list2(s_op_ping_fixed, 
+                                      pmt_list2(pmt_from_long(3), 
+                                      pmt_from_long(0))))));
+  
+  d_tx->send(s_cmd_to_control_channel,
+             pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T),
+                       pmt_list1(
+                            pmt_list2(s_op_write_reg, 
+                                      pmt_list2(
+                                      pmt_from_long(0x3), 
+                                      pmt_from_long(0x4))))));
+  
+  d_tx->send(s_cmd_to_control_channel,
+             pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T),
+                       pmt_list1(
+                            pmt_list2(s_op_write_reg_masked, 
+                                      pmt_list3(
+                                      pmt_from_long(0x3), 
+                                      pmt_from_long(0x4),
+                                      pmt_from_long(0x5))))));
+  
+  d_tx->send(s_cmd_to_control_channel,
+             pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T),
+                       pmt_list1(
+                            pmt_list2(s_op_read_reg, 
+                                      pmt_list2(pmt_from_long(0), 
+                                      pmt_from_long(0x6))))));
+  
+  d_tx->send(s_cmd_to_control_channel,
+             pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T),
+                       pmt_list1(
+                            pmt_list2(s_op_delay, 
+                                      pmt_list1(pmt_from_long(0x7))))));
+
+  pmt_t subpackets = pmt_list5(
+                        pmt_list2(s_op_ping_fixed, pmt_list2(pmt_from_long(0), pmt_from_long(0))),
+                        pmt_list2(s_op_delay, pmt_list1(pmt_from_long(0x7))),
+                        pmt_list2(s_op_write_reg_masked, pmt_list3(pmt_from_long(3),
+                                                                   pmt_from_long(4),
+                                                                   pmt_from_long(5))),
+                        pmt_list2(s_op_write_reg, pmt_list2(pmt_from_long(3),
+                                                            pmt_from_long(4))),
+                        pmt_list2(s_op_read_reg, pmt_list2(pmt_from_long(0),
+                                                           pmt_from_long(6)))
+                     );
+
+  d_tx->send(s_cmd_to_control_channel, 
+              pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T),
+                        subpackets));
+
+  pmt_t i2c_data = pmt_make_u8vector(8, 0xff);
+
+  subpackets = pmt_list2(
+                        pmt_list2(s_op_i2c_write, 
+                                  pmt_list2(pmt_from_long(8), i2c_data)),
+                        pmt_list2(s_op_i2c_read,
+                                  pmt_list3(pmt_from_long(0), pmt_from_long(9), pmt_from_long(1)))
+
+                     );
+
+  d_tx->send(s_cmd_to_control_channel, 
+              pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T),
+                        subpackets));
+  
+}
+
+void
+qa_cs_top::handle_message(mb_message_sptr msg)
+{
+  pmt_t data = msg->data();
+
+  if ((pmt_eq(msg->port_id(), d_tx->port_symbol())
+       || pmt_eq(msg->port_id(), d_rx->port_symbol()))
+       && pmt_eq(msg->signal(), s_response_allocate_channel))
+    check_message(msg);
+
+  if (pmt_eq(msg->port_id(), d_tx->port_symbol())
+      && pmt_eq(msg->signal(), s_response_from_control_channel))
+    check_message(msg);
+  
+  if (pmt_eq(msg->port_id(), d_cs->port_symbol())) {
+      
+    if(pmt_eq(msg->signal(), s_response_max_capacity)) {
+      d_max_capacity = pmt_to_long(pmt_nth(2, data));
+      if(verbose)
+        std::cout << "[qa_cs_top] USRP has max capacity of " 
+                  << d_max_capacity << "\n";
+    }
+    else if(pmt_eq(msg->signal(), s_response_ntx_chan)) {
+      d_ntx_chan = pmt_to_long(pmt_nth(2, data));
+      if(verbose)
+        std::cout << "[qa_cs_top] USRP tx channels: " 
+                  << d_ntx_chan << "\n";
+    }
+    else if(pmt_eq(msg->signal(), s_response_nrx_chan)) {
+      d_nrx_chan = pmt_to_long(pmt_nth(2, data));
+      if(verbose)
+        std::cout << "[qa_cs_top] USRP rx channels: " 
+                  << d_nrx_chan << "\n";
+    }
+    else if(pmt_eq(msg->signal(), s_response_current_capacity_allocation)) {
+      check_message(msg);
+    }
+    
+    d_nstatus++;
+
+    check_message(msg);
+
+    if(d_nstatus==d_nstatus_to_recv)
+      run_tests();
+  }
+}
+
+void
+qa_cs_top::check_message(mb_message_sptr msg)
+{
+  pmt_t data = msg->data();
+  pmt_t event = msg->signal();
+
+  pmt_t expected = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+
+  pmt_t e_event = pmt_nth(0, expected);
+  pmt_t e_status = pmt_nth(1, expected);
+  
+  d_nrecvd++;
+
+
+  if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) {
+    if(verbose)
+      std::cout << "[qa_cs_top] Got: " << status << " Expected: " << e_status << "\n";
+    shutdown_all(PMT_F);
+    return;
+  } else {
+    if(verbose)
+      std::cout << "[qa_cs_top] Received expected response for message " 
+                << d_nrecvd << " (" << event << ")\n";
+  }
+
+  if(d_nrecvd == d_nmsgs_to_recv)
+    shutdown_all(PMT_T);
+}
+
+REGISTER_MBLOCK_CLASS(qa_cs_top);
 
 // ----------------------------------------------------------------------------------------------
 
 void 
+qa_inband_usrp_server::test_open_close()
+{
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_T;
+
+  // std::cout << "\n\n----------------------------\n";
+  // std::cout << "    RUNNING OPEN/CLOSE TESTS  \n";
+
+  rt->run("top", "qa_open_close_top", PMT_F, &result);
+
+  CPPUNIT_ASSERT(pmt_equal(PMT_T, result));
+}
+
+void 
 qa_inband_usrp_server::test_chan_allocation()
 {
   mb_runtime_sptr rt = mb_make_runtime();
   pmt_t result = PMT_T;
 
-  rt->run("top", "qa_alloc_top", PMT_F, &result);
+  // std::cout << "\n\n----------------------------\n";
+  // std::cout << "    RUNNING ALLOCATION TESTS  \n";
+
+  rt->run("qa_alloc_top", "qa_alloc_top", PMT_F, &result);
   
   CPPUNIT_ASSERT(pmt_equal(PMT_T, result));
 }
@@ -443,13 +1349,52 @@ qa_inband_usrp_server::test_chan_deallocation()
   mb_runtime_sptr rt = mb_make_runtime();
   pmt_t result = PMT_T;
 
-  rt->run("top", "qa_dealloc_top", PMT_F, &result);
+  // std::cout << "\n\n----------------------------\n";
+  // std::cout << "  RUNNING DEALLOCATION TESTS  \n";
+
+  rt->run("qa_dealloc_top", "qa_dealloc_top", PMT_F, &result);
+  
+  CPPUNIT_ASSERT(pmt_equal(PMT_T, result));
+}
+
+void
+qa_inband_usrp_server::test_tx()
+{
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_T;
+
+  // std::cout << "\n\n-----------------\n";
+  // std::cout << "  RUNNING TX TESTS  \n";
+
+  rt->run("top", "qa_tx_top", PMT_F, &result);
+  
+  CPPUNIT_ASSERT(pmt_equal(PMT_T, result));
+}
+
+void
+qa_inband_usrp_server::test_rx()
+{
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_T;
+
+  // std::cout << "\n\n-----------------\n";
+  // std::cout << "  RUNNING RX TESTS  \n";
+
+  rt->run("top", "qa_rx_top", PMT_F, &result);
   
   CPPUNIT_ASSERT(pmt_equal(PMT_T, result));
 }
 
 void
-qa_inband_usrp_server::test_fragmentation()
+qa_inband_usrp_server::test_cs()
 {
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_T;
+
+  // std::cout << "\n\n-----------------\n";
+  // std::cout << "  RUNNING CS TESTS  \n";
+
+  rt->run("top", "qa_cs_top", PMT_F, &result);
   
+  CPPUNIT_ASSERT(pmt_equal(PMT_T, result));
 }
diff --git a/usrp/host/lib/inband/qa_inband_usrp_server.h b/usrp/host/lib/inband/qa_inband_usrp_server.h
index 91cf7d87c..5db57c3ed 100644
--- a/usrp/host/lib/inband/qa_inband_usrp_server.h
+++ b/usrp/host/lib/inband/qa_inband_usrp_server.h
@@ -28,15 +28,21 @@
 class qa_inband_usrp_server : public CppUnit::TestCase {
 
   CPPUNIT_TEST_SUITE(qa_inband_usrp_server);
+  CPPUNIT_TEST(test_open_close);
   CPPUNIT_TEST(test_chan_allocation);
   CPPUNIT_TEST(test_chan_deallocation);
-  CPPUNIT_TEST(test_fragmentation);
+  CPPUNIT_TEST(test_tx);
+  CPPUNIT_TEST(test_rx);
+  CPPUNIT_TEST(test_cs);
   CPPUNIT_TEST_SUITE_END();
 
  private:
   void test_chan_allocation();
   void test_chan_deallocation();
-  void test_fragmentation();
+  void test_open_close();
+  void test_tx();
+  void test_rx();
+  void test_cs();
 };
 
 #endif /* INCLUDED_QA_INBAND_USRP_SERVER_H */
diff --git a/usrp/host/lib/inband/symbols_usrp_channel.h b/usrp/host/lib/inband/symbols_usrp_channel.h
new file mode 100644
index 000000000..a0114cf3c
--- /dev/null
+++ b/usrp/host/lib/inband/symbols_usrp_channel.h
@@ -0,0 +1,40 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_SYMBOLS_USRP_CHANNEL_H
+#define INCLUDED_SYMBOLS_USRP_CHANNEL_H
+
+#include <pmt.h>
+
+// Outgoing
+static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel");
+static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel");
+
+// Incoming
+static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel");
+static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel");
+
+// Errors
+static pmt_t s_err_requested_capacity_unavailable = pmt_intern("err-requested-capacity-unavailable");
+static pmt_t s_err_channel_unavailable = pmt_intern("err-channel-unavailable");
+static pmt_t s_err_channel_invalid = pmt_intern("err-channel-invalid");
+static pmt_t s_err_channel_permission_denied = pmt_intern("err-channel-permission-denied");
+
+#endif /* INCLUDED_SYMBOLS_USRP_CHANNEL_H */
diff --git a/usrp/host/lib/inband/symbols_usrp_interface_cs.h b/usrp/host/lib/inband/symbols_usrp_interface_cs.h
new file mode 100644
index 000000000..72c8fcc91
--- /dev/null
+++ b/usrp/host/lib/inband/symbols_usrp_interface_cs.h
@@ -0,0 +1,43 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_SYMBOLS_USRP_INTERFACE_CS_H
+#define INCLUDED_SYMBOLS_USRP_INTERFACE_CS_H
+
+#include <pmt.h>
+
+// Outgoing
+static pmt_t s_cmd_usrp_open = pmt_intern("cmd-usrp-open");
+static pmt_t s_cmd_usrp_close = pmt_intern("cmd-usrp-close");
+static pmt_t s_cmd_usrp_ntx_chan = pmt_intern("cmd-usrp-ntx-chan");
+static pmt_t s_cmd_usrp_nrx_chan = pmt_intern("cmd-usrp-nrx-chan");
+static pmt_t s_cmd_usrp_write = pmt_intern("cmd-usrp-write");
+static pmt_t s_cmd_usrp_start_reading = pmt_intern("cmd-usrp-start-reading");
+static pmt_t s_cmd_usrp_stop_reading = pmt_intern("cmd-usrp-stop-reading");
+
+// Incoming
+static pmt_t s_response_usrp_open = pmt_intern("response-usrp-open");
+static pmt_t s_response_usrp_close = pmt_intern("response-usrp-close");
+static pmt_t s_response_usrp_ntx_chan = pmt_intern("response-usrp-ntx-chan");
+static pmt_t s_response_usrp_nrx_chan = pmt_intern("response-usrp-nrx-chan");
+static pmt_t s_response_usrp_write = pmt_intern("response-usrp-write");
+static pmt_t s_response_usrp_read = pmt_intern("response-usrp-read");
+
+#endif /* INCLUDED_SYMBOLS_USRP_INTERFACE_CS_H */
diff --git a/usrp/host/lib/inband/symbols_usrp_low_level_cs.h b/usrp/host/lib/inband/symbols_usrp_low_level_cs.h
new file mode 100644
index 000000000..a7260603a
--- /dev/null
+++ b/usrp/host/lib/inband/symbols_usrp_low_level_cs.h
@@ -0,0 +1,47 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_SYMBOLS_USRP_LOW_LEVEL_CS_H
+#define INCLUDED_SYMBOLS_USRP_LOW_LEVEL_CS_H
+
+#include <pmt.h>
+
+// Outgoing
+static pmt_t s_cmd_to_control_channel = pmt_intern("cmd-to-control-channel");
+
+// Incoming
+static pmt_t s_response_from_control_channel = pmt_intern("response-from-control-channel");
+
+// Subpackets
+static pmt_t s_op_ping_fixed = pmt_intern("op-ping-fixed");
+static pmt_t s_op_ping_fixed_reply = pmt_intern("op-ping-fixed-reply");
+static pmt_t s_op_write_reg = pmt_intern("op-write-reg");
+static pmt_t s_op_write_reg_masked = pmt_intern("op-write-reg-masked");
+static pmt_t s_op_read_reg = pmt_intern("op-read-reg");
+static pmt_t s_op_read_reg_reply = pmt_intern("op-read-reg-reply");
+static pmt_t s_op_i2c_write = pmt_intern("op-i2c-write");
+static pmt_t s_op_i2c_read = pmt_intern("op-i2c-read");
+static pmt_t s_op_i2c_read_reply = pmt_intern("op-i2c-read-reply");
+static pmt_t s_op_spi_write = pmt_intern("op-spi-write");
+static pmt_t s_op_spi_read = pmt_intern("op-spi-read");
+static pmt_t s_op_spi_read_reply = pmt_intern("op-spi-read-reply");
+static pmt_t s_op_delay = pmt_intern("op-delay");
+
+#endif /* INCLUDED_SYMBOLS_USRP_LOW_LEVEL_CS_H */
diff --git a/usrp/host/lib/inband/symbols_usrp_rx.h b/usrp/host/lib/inband/symbols_usrp_rx.h
new file mode 100644
index 000000000..07d58a3f5
--- /dev/null
+++ b/usrp/host/lib/inband/symbols_usrp_rx.h
@@ -0,0 +1,36 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_SYMBOLS_USRP_RX_H
+#define INCLUDED_SYMBOLS_USRP_RX_H
+
+#include <pmt.h>
+
+// Outgoing
+static pmt_t s_cmd_start_recv_raw_samples = pmt_intern("cmd-start-recv-raw-samples");
+static pmt_t s_cmd_stop_recv_raw_samples = pmt_intern("cmd-stop-recv-raw-samples");
+
+// Incoming
+static pmt_t s_response_recv_raw_samples = pmt_intern("response-recv-raw-samples");
+
+// Errors
+static pmt_t s_err_already_receiving = pmt_intern("err-already-receiving");
+
+#endif /* INCLUDED_SYMBOLS_USRP_RX_H */
diff --git a/usrp/host/lib/inband/symbols_usrp_rx_cs.h b/usrp/host/lib/inband/symbols_usrp_rx_cs.h
new file mode 100644
index 000000000..bf4f0338b
--- /dev/null
+++ b/usrp/host/lib/inband/symbols_usrp_rx_cs.h
@@ -0,0 +1,32 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_SYMBOLS_USRP_RX_CS_H
+#define INCLUDED_SYMBOLS_USRP_RX_CS_H
+
+#include <pmt.h>
+
+// Outgoing
+static pmt_t s_cmd_usrp_rx_start_reading = pmt_intern("cmd-usrp-rx-start-reading");
+
+// Incoming
+static pmt_t s_response_usrp_rx_read = pmt_intern("response-usrp-rx-read");
+
+#endif /* INCLUDED_SYMBOLS_USRP_RX_CS_H */
diff --git a/usrp/host/lib/inband/symbols_usrp_server_cs.h b/usrp/host/lib/inband/symbols_usrp_server_cs.h
new file mode 100644
index 000000000..e612e24ea
--- /dev/null
+++ b/usrp/host/lib/inband/symbols_usrp_server_cs.h
@@ -0,0 +1,47 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_SYMBOLS_USRP_SERVER_CS_H
+#define INCLUDED_SYMBOLS_USRP_SERVER_CS_H
+
+#include <pmt.h>
+
+// Outgoing
+static pmt_t s_cmd_open = pmt_intern("cmd-open");
+static pmt_t s_cmd_close = pmt_intern("cmd-close");
+static pmt_t s_cmd_max_capacity  = pmt_intern("cmd-max-capacity");
+static pmt_t s_cmd_ntx_chan  = pmt_intern("cmd-ntx-chan");
+static pmt_t s_cmd_nrx_chan  = pmt_intern("cmd-nrx-chan");
+static pmt_t s_cmd_current_capacity_allocation  = pmt_intern("cmd-current-capacity-allocation");
+
+// Incoming
+static pmt_t s_response_open = pmt_intern("response-open");
+static pmt_t s_response_close = pmt_intern("response-close");
+static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity");
+static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan");
+static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan");
+static pmt_t s_response_current_capacity_allocation  = pmt_intern("response-current-capacity-allocation");
+
+// Errors
+static pmt_t s_err_usrp_not_opened = pmt_intern("err-usrp-not-opened");
+static pmt_t s_err_usrp_already_opened = pmt_intern("err-usrp-already-opened");
+static pmt_t s_err_usrp_already_closed = pmt_intern("err-usrp-already-closed");
+
+#endif /* INCLUDED_SYMBOLS_USRP_SERVER_CS_H */
diff --git a/usrp/host/lib/inband/symbols_usrp_tx.h b/usrp/host/lib/inband/symbols_usrp_tx.h
new file mode 100644
index 000000000..4e58e2cf9
--- /dev/null
+++ b/usrp/host/lib/inband/symbols_usrp_tx.h
@@ -0,0 +1,32 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_SYMBOLS_USRP_TX_H
+#define INCLUDED_SYMBOLS_USRP_TX_H
+
+#include <pmt.h>
+
+// Outgoing
+static pmt_t s_cmd_xmit_raw_frame  = pmt_intern("cmd-xmit-raw-frame");
+
+// Incoming
+static pmt_t s_response_xmit_raw_frame = pmt_intern("response-xmit-raw-frame");
+
+#endif /* INCLUDED_SYMBOLS_USRP_TX_H */
diff --git a/usrp/host/lib/inband/symbols_usrp_tx_cs.h b/usrp/host/lib/inband/symbols_usrp_tx_cs.h
new file mode 100644
index 000000000..d02ef1d26
--- /dev/null
+++ b/usrp/host/lib/inband/symbols_usrp_tx_cs.h
@@ -0,0 +1,32 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_SYMBOLS_USRP_TX_CS_H
+#define INCLUDED_SYMBOLS_USRP_TX_CS_H
+
+#include <pmt.h>
+
+// Outgoing
+static pmt_t s_cmd_usrp_tx_write = pmt_intern("cmd-usrp-tx-write");
+
+// Incoming
+static pmt_t s_response_usrp_tx_write = pmt_intern("response-usrp-tx-write");
+
+#endif /* INCLUDED_SYMBOLS_USRP_TX_CS_H */
diff --git a/usrp/host/lib/inband/test_usrp_inband.cc b/usrp/host/lib/inband/test_usrp_inband.cc
new file mode 100644
index 000000000..dd8d46f84
--- /dev/null
+++ b/usrp/host/lib/inband/test_usrp_inband.cc
@@ -0,0 +1,297 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <iostream>
+#include <usrp_inband_usb_packet.h>
+#include <mb_mblock.h>
+#include <mb_runtime.h>
+#include <mb_protocol_class.h>
+#include <mb_class_registry.h>
+#include <pmt.h>
+#include "usrp_standard.h"
+
+typedef usrp_inband_usb_packet transport_pkt; 
+
+// Signal set for the USRP server
+static pmt_t s_cmd_open = pmt_intern("cmd-open");
+static pmt_t s_response_open = pmt_intern("response-open");
+static pmt_t s_cmd_close = pmt_intern("cmd-close");
+static pmt_t s_response_close = pmt_intern("response-close");
+static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel");
+static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel");
+static pmt_t s_send_allocate_channel = pmt_intern("send-allocate-channel");
+static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel");
+static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel");
+static pmt_t s_send_deallocate_channel = pmt_intern("send-deallocate-channel");
+static pmt_t s_cmd_max_capacity = pmt_intern("cmd-max-capacity");
+static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity");
+static pmt_t s_cmd_ntx_chan  = pmt_intern("cmd-ntx-chan");
+static pmt_t s_cmd_nrx_chan  = pmt_intern("cmd-nrx-chan");
+static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan");
+static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan");
+static pmt_t s_cmd_current_capacity_allocation  = pmt_intern("cmd-current-capacity-allocation");
+static pmt_t s_response_current_capacity_allocation  = pmt_intern("response-current-capacity-allocation");
+static pmt_t s_cmd_xmit_raw_frame  = pmt_intern("cmd-xmit-raw-frame");
+static pmt_t s_response_xmit_raw_frame = pmt_intern("response-xmit-raw-frame");
+
+bool loopback_p = false;
+bool counting_p = false;
+bool fake_usrp_p = false;
+char *prog_name;
+
+static void
+set_progname (char *path)
+{
+  char *p = strrchr (path, '/');
+  if (p != 0)
+    prog_name = p+1;
+  else
+    prog_name = path;
+}
+
+static void
+usage()
+{
+  fprintf (stderr, "usage: %s [-l]\n", prog_name);
+  fprintf (stderr, "  [-l] digital loopback in FPGA\n");
+  fprintf (stderr, "  [-c] counting in FPGA\n");
+  fprintf (stderr, "  [-f] fake usrp\n");
+
+  exit(1);
+}
+
+int
+main(int argc, char **argv)
+{
+  int ch;
+
+  set_progname(argv[0]);
+
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_T;
+
+  while ((ch = getopt(argc, argv, "flc")) != EOF) {
+    switch(ch) {
+    
+      case 'l':
+        loopback_p = true;
+        break;
+
+      case 'c':
+        counting_p = true;
+        break;
+      
+      case 'f':
+        fake_usrp_p = true;
+        break;
+
+      default:
+        usage();
+    }
+  }
+
+
+  std::cout << "[test_usrp_inband] Starting...\n";
+
+  rt->run("top", "test_usrp_inband_top", PMT_F, &result);
+}
+
+class test_usrp_inband_top : public mb_mblock
+{
+  mb_port_sptr d_tx;
+  mb_port_sptr d_cs;
+
+  long d_tx_chan;
+
+ public:
+  test_usrp_inband_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~test_usrp_inband_top();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void open_usrp();
+  void close_usrp();
+  void check_message(mb_message_sptr msg);
+  void allocate_channel();
+  void send_packets();
+};
+
+test_usrp_inband_top::test_usrp_inband_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg)
+{ 
+  std::cout << "[TEST_USRP_INBAND_TOP] Initializing...\n";
+  
+  d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+  
+  // Test the TX side
+
+  // Pass a dictionary to usrp_server which specifies which interface to use, the stub or USRP
+  pmt_t usrp_server_dict = pmt_make_dict();
+
+  if(fake_usrp_p)
+    pmt_dict_set(usrp_server_dict, pmt_intern("usrp-interface"), pmt_intern("usrp_usb_interface_stub"));
+
+  define_component("server", "usrp_server", usrp_server_dict);
+  connect("self", "tx0", "server", "tx0");
+  connect("self", "cs", "server", "cs");
+}
+
+test_usrp_inband_top::~test_usrp_inband_top()
+{
+}
+
+void
+test_usrp_inband_top::initial_transition()
+{
+  open_usrp();
+}
+
+void
+test_usrp_inband_top::handle_message(mb_message_sptr msg)
+{
+  pmt_t event = msg->signal();		// the "name" of the message
+  pmt_t port_id = msg->port_id();	// which port it came in on
+  pmt_t data = msg->data();
+  pmt_t metadata = msg->metadata();
+  pmt_t status;
+
+  if (pmt_eq(port_id, d_cs->port_symbol())) {	// message came in on our control/status port
+
+    //---------- OPEN RESPONSE ----------//
+    if (pmt_eq(event, s_response_open)) {
+      status = pmt_nth(1, data);
+
+      if(pmt_eq(status, PMT_T)) {
+        std::cout << "[TEST_USRP_INBAND_TOP] Success opening USRP\n";
+      }
+      else {
+        std::cout << "[TEST_USRP_INBAND_TOP] Received error message opening USRP\n";
+        shutdown_all(PMT_F);
+      }
+
+      allocate_channel();
+
+      return;
+    }
+    //--------- CLOSE RESPONSE -----------//
+    else if (pmt_eq(event, s_response_close)) {
+      status = pmt_nth(1, data);
+      
+      if(pmt_eq(status, PMT_T)) {
+        std::cout << "[TEST_USRP_INBAND_TOP] Successfully closed USRP\n";
+      }
+      else {
+        std::cout << "[TEST_USRP_INBAND_TOP] Received error message closing USRP\n";
+        shutdown_all(PMT_F);
+      }
+
+      shutdown_all(PMT_T);
+
+      return;
+    }
+  }
+    
+  if (pmt_eq(port_id, d_tx->port_symbol())) {
+
+    //---------- ALLOCATE RESPONSE ---------//
+    if(pmt_eq(event, s_response_allocate_channel)) {
+      status = pmt_nth(1, data);
+      pmt_t channel = pmt_nth(2, data);
+
+      if(pmt_eq(status, PMT_T)) {
+        d_tx_chan = pmt_to_long(channel);
+        std::cout << "[TEST_USRP_INBAND_TOP] Received allocation on channel " << d_tx_chan << "\n";
+      }
+      else {
+        std::cout << "[TEST_USRP_INBAND_TOP] Error allocating channel\n";
+        shutdown_all(PMT_F);
+      }
+      
+      send_packets();
+
+      return;
+    }
+    //----------- XMIT RESPONSE ------------//
+    else if(pmt_eq(event, s_response_xmit_raw_frame)) {
+      status = pmt_nth(1, data);
+
+      if(pmt_eq(status, PMT_T)) {
+        std::cout << "[TEST_USRP_INBAND_TOP] Transmission successful\n";
+      }
+      else {
+        std::cout << "[TEST_USRP_INBAND_TOP] Failed transmission\n";
+        shutdown_all(PMT_F);
+      }
+
+      close_usrp();
+
+      return;
+    }
+  }
+
+  std::cout << "[TEST_USRP_INBAND_TOP] Received unhandled message: " << event << "\n";
+}
+
+void
+test_usrp_inband_top::allocate_channel()
+{
+  std::cout << "[TEST_USRP_INBAND_TOP] Requesting channel allocation...\n";
+  
+  d_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(1)));
+}
+
+void
+test_usrp_inband_top::send_packets()
+{
+  std::cout << "[TEST_USRP_INBAND_TOP] Sending single packet..\n";
+  d_tx->send(s_cmd_xmit_raw_frame, pmt_list4(pmt_from_long(1), pmt_from_long(d_tx_chan), pmt_make_u32vector(transport_pkt::max_payload()/4, 0), pmt_from_long(0)));
+  
+}
+
+void
+test_usrp_inband_top::open_usrp()
+{
+  pmt_t usrp = pmt_from_long(0);
+
+  long rx_mode = 0;
+
+  if(loopback_p)
+    rx_mode |= usrp_standard_rx::FPGA_MODE_LOOPBACK;
+  if(counting_p)
+    rx_mode |= usrp_standard_rx::FPGA_MODE_COUNTING;
+
+  d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, usrp));
+}
+
+void
+test_usrp_inband_top::close_usrp()
+{
+  d_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
+}
+
+REGISTER_MBLOCK_CLASS(test_usrp_inband_top);
diff --git a/usrp/host/lib/inband/usrp_inband_usb_packet.cc b/usrp/host/lib/inband/usrp_inband_usb_packet.cc
new file mode 100644
index 000000000..b8befa493
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_inband_usb_packet.cc
@@ -0,0 +1,749 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <usrp_inband_usb_packet.h>
+
+#include <usrp_bytesex.h>
+#include <iostream>
+#include <stdio.h>
+
+bool usrp_inband_usb_packet::align32()
+{
+  int p_len = payload_len();
+
+  int bytes_needed = 4 - (p_len % 4);
+
+  if(bytes_needed == 4)
+    return true;
+
+  // If the room left in the packet is less than the number of bytes
+  // needed, return false to indicate no room to align
+  if((MAX_PAYLOAD - p_len) < bytes_needed)
+    return false;
+    
+  p_len += bytes_needed;
+
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = p_len;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_ping(long rid, long ping_val)
+{
+  if(!align32())
+    return false;
+  
+  int p_len = payload_len();
+
+  if((MAX_PAYLOAD - p_len) < (CS_PING_LEN + CS_FIXED_LEN))
+    return false;
+
+  uint32_t ping = ( 
+      ((OP_PING_FIXED & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((CS_PING_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
+    | (ping_val & CS_PINGVAL_MASK)
+
+    );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(ping);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + CS_PING_LEN;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+
+bool usrp_inband_usb_packet::cs_ping_reply(long rid, long ping_val) 
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  if((MAX_PAYLOAD - p_len) < (CS_PING_LEN + CS_FIXED_LEN))
+    return false;
+
+  uint32_t ping = ( 
+      ((OP_PING_FIXED_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((CS_PING_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
+    | ((ping_val & CS_PINGVAL_MASK) << CS_PINGVAL_SHIFT)
+
+    );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(ping);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + CS_PING_LEN;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_write_reg(long reg_num, long val)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  if((MAX_PAYLOAD - p_len) < (CS_WRITEREG_LEN + CS_FIXED_LEN))
+    return false;
+
+  uint32_t word0 = 0;
+
+  // Build the first word which includes the register number
+  word0 = (
+      ((OP_WRITE_REG & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((CS_WRITEREG_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT)
+  );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word0);
+
+  // The second word is solely the register value to be written
+  // FIXME: should this be unsigned?
+  payload += 1; 
+  *payload = host_to_usrp_u32((uint32_t) val);
+  
+  // Rebuild the header to update the payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + CS_WRITEREG_LEN;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_write_reg_masked(long reg_num, long val, long mask)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  if((MAX_PAYLOAD - p_len) < (CS_WRITEREGMASKED_LEN + CS_FIXED_LEN))
+    return false;
+
+  uint32_t word0 = 0;
+
+  // Build the first word which includes the register number
+  word0 = (
+      ((OP_WRITE_REG_MASKED & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((CS_WRITEREGMASKED_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT)
+  );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word0);
+
+  // Skip over the first word and write the register value
+  payload += 1;
+  *payload = host_to_usrp_u32((uint32_t) val);
+
+  // Skip over the register value and write the mask
+  payload += 1;
+  *payload = host_to_usrp_u32((uint32_t) mask);
+  
+  // Rebuild the header to update the payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + CS_WRITEREGMASKED_LEN;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_read_reg(long rid, long reg_num)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  if((MAX_PAYLOAD - p_len) < (CS_READREG_LEN + CS_FIXED_LEN))
+    return false;
+
+  uint32_t read_reg = ( 
+      ((OP_READ_REG & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((CS_READREG_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
+    | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT)
+
+    );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(read_reg);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + CS_READREG_LEN;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_read_reg_reply(long rid, long reg_num, long reg_val)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  if((MAX_PAYLOAD - p_len) < (CS_READREGREPLY_LEN + CS_FIXED_LEN))
+    return false;
+
+  uint32_t word0 = ( 
+      ((OP_READ_REG_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((CS_READREGREPLY_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
+    | ((reg_num & CS_REGNUM_MASK) << CS_REGNUM_SHIFT)
+
+    );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word0);
+
+  // Hop to the next word and write the reg value
+  payload += 1;
+  *payload = host_to_usrp_u32((uint32_t) reg_val); 
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + CS_READREGREPLY_LEN;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_delay(long ticks)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  if((MAX_PAYLOAD - p_len) < (CS_DELAY_LEN + CS_FIXED_LEN))
+    return false;
+
+  uint32_t delay = ( 
+      ((OP_DELAY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((CS_DELAY_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((ticks & CS_DELAY_MASK) << CS_DELAY_SHIFT)
+
+    );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(delay);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + CS_DELAY_LEN;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_i2c_write(long i2c_addr, uint8_t *i2c_data, size_t data_len)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  int i2c_len = data_len + 2;   // 2 bytes between mbz and addr
+
+  if((MAX_PAYLOAD - p_len) < (i2c_len + CS_FIXED_LEN))
+    return false;
+
+  uint32_t word0 = 0;
+
+  word0 = (
+      ((OP_I2C_WRITE & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((i2c_len & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((i2c_addr & CS_I2CADDR_MASK) << CS_I2CADDR_SHIFT)
+  );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+   *payload = host_to_usrp_u32(word0);
+
+   // Jump over the first word and write the data
+   // FIXME: Should the data be changed to usrp byte order?
+   payload += 1;
+   memcpy(payload, i2c_data, data_len);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + i2c_len;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_i2c_read(long rid, long i2c_addr, long n_bytes)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  if((MAX_PAYLOAD - p_len) < (CS_I2CREAD_LEN + CS_FIXED_LEN))
+    return false;
+
+  uint32_t word0 = 0;
+  
+  word0 = ( 
+      ((OP_I2C_READ & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((CS_I2CREAD_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
+    | ((i2c_addr & CS_I2CADDR_MASK) << CS_I2CADDR_SHIFT)
+    );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word0);
+
+  // Jump a word and write the number of bytes to read
+  payload += 1;
+  uint32_t word1 = 
+    (n_bytes & CS_I2CREADBYTES_MASK) << CS_I2CREADBYTES_SHIFT;
+  *payload = host_to_usrp_u32(word1);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + CS_I2CREAD_LEN;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_i2c_read_reply(long rid, long i2c_addr, uint8_t *i2c_data, long i2c_data_len)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  int i2c_len = i2c_data_len + 2;
+
+  if((MAX_PAYLOAD - p_len) < (i2c_len + CS_FIXED_LEN)) 
+    return false;
+  
+  uint32_t word0 = 0;
+  
+  word0 = ( 
+      ((OP_I2C_READ_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((i2c_len & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
+    | ((i2c_addr & CS_I2CADDR_MASK) << CS_I2CADDR_SHIFT)
+    );
+
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word0);
+
+  // Jump a word and write the actual data
+  payload += 1;
+  memcpy(payload, i2c_data, i2c_data_len);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + i2c_len;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_spi_write(long enables, long format, long opt_header_bytes, uint8_t *spi_data, long spi_data_len)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  int spi_len = spi_data_len + 6;
+
+  if((MAX_PAYLOAD - p_len) < (spi_len + CS_FIXED_LEN))
+    return false;
+
+  uint32_t word = 0;
+
+  // First word contains the opcode and length, then mbz
+  word = (
+      ((OP_SPI_WRITE & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((spi_len & CS_LEN_MASK) << CS_LEN_SHIFT)
+    );
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word);
+
+  payload += 1;
+
+  // Second word contains the enables, format, and optional tx bytes
+  word = 0;
+  word = (
+      ((enables & CS_SPIENABLES_MASK) << CS_SPIENABLES_SHIFT)
+    | ((format & CS_SPIFORMAT_MASK) << CS_SPIFORMAT_SHIFT)
+    | ((opt_header_bytes & CS_SPIOPT_MASK) << CS_SPIOPT_SHIFT)
+    );
+  payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word);
+
+  payload += 1;
+  memcpy(payload, spi_data, spi_data_len);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + spi_len;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_spi_read(long rid, long enables, long format, long opt_header_bytes, long n_bytes)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  if((MAX_PAYLOAD - p_len) < (CS_SPIREAD_LEN + CS_FIXED_LEN))
+    return false;
+
+  uint32_t word = 0;
+
+  // First word contains the opcode, length, and RID
+  word = (
+      ((OP_SPI_READ & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((CS_SPIREAD_LEN & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
+    );
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word);
+
+  payload += 1;
+
+  // Second word contains the enables, format, and optional tx bytes
+  word = 0;
+  word = (
+      ((enables & CS_SPIENABLES_MASK) << CS_SPIENABLES_SHIFT)
+    | ((format & CS_SPIFORMAT_MASK) << CS_SPIFORMAT_SHIFT)
+    | ((opt_header_bytes & CS_SPIOPT_MASK) << CS_SPIOPT_SHIFT)
+    );
+  payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word);
+
+  payload += 1;
+
+  // The third word contains the number of bytes
+  word = 0;
+  word = (
+      ((n_bytes & CS_SPINBYTES_MASK) << CS_SPINBYTES_SHIFT)
+    );
+  payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + CS_SPIREAD_LEN;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+  
+  return true;
+}
+
+bool usrp_inband_usb_packet::cs_spi_read_reply(long rid, uint8_t *spi_data, long spi_data_len)
+{
+  if(!align32())
+    return false;
+
+  int p_len = payload_len();
+
+  int spi_len = spi_data_len + 2;
+
+  if((MAX_PAYLOAD - p_len) < (spi_len + CS_FIXED_LEN))
+    return false;
+
+  uint32_t word = 0;
+
+  // First word contains the opcode, length, and RID
+  word = (
+      ((OP_SPI_READ_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+    | ((spi_len & CS_LEN_MASK) << CS_LEN_SHIFT)
+    | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
+    );
+  uint32_t *payload = (uint32_t *) (d_payload + p_len);
+  *payload = host_to_usrp_u32(word);
+
+  // Jump a word and write the actual data
+  payload += 1;
+  memcpy(payload, spi_data, spi_data_len);
+
+  // Update payload length
+  int h_flags = flags();
+  int h_chan = chan();
+  int h_tag = tag();
+  int h_payload_len = payload_len() + CS_FIXED_LEN + spi_len;
+
+  set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+  return true;
+}
+
+// Takes an offset to the beginning of a subpacket and extracts the
+// length of the subpacket
+int usrp_inband_usb_packet::cs_len(int payload_offset) {
+  uint32_t subpkt = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset)));
+  return (subpkt >> CS_LEN_SHIFT) & CS_LEN_MASK;
+}
+
+// The following method takes an offset within the packet payload to extract
+// a control/status subpacket and construct a pmt response which includes the
+// proper signal and arguments specified by usrp-low-level-cs.  The USRP
+// server could therefore use this to read subpackets and pass them responses
+// back up to the application.  It's arguable that only reply packets should
+// be parsed here, however we parse others for use in debugging or failure
+// reporting on the transmit side of packets.
+pmt_t usrp_inband_usb_packet::read_subpacket(int payload_offset) {
+
+  uint32_t subpkt = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset)));
+  uint32_t opcode = (subpkt >> CS_OPCODE_SHIFT) & CS_OPCODE_MASK;
+  uint32_t len = (subpkt >> CS_LEN_SHIFT) & CS_LEN_MASK;
+
+  switch(opcode) {
+    
+    case OP_PING_FIXED_REPLY:
+    {
+      pmt_t rid     = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK);
+      pmt_t pingval = pmt_from_long((subpkt >> CS_PINGVAL_SHIFT) & CS_PINGVAL_MASK);
+      return pmt_list3(s_op_ping_fixed_reply, rid, pingval);
+    }
+
+    case OP_READ_REG_REPLY:
+    {
+      pmt_t rid     = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK);
+      pmt_t reg_num = pmt_from_long((subpkt >> CS_REGNUM_SHIFT) & CS_REGNUM_MASK);
+
+      // To get the register value we just read the next 32 bits
+      uint32_t val  = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4)));
+      pmt_t reg_val = pmt_from_long(val);
+
+      return pmt_list4(s_op_read_reg_reply, rid, reg_num, reg_val);
+    }
+
+    case OP_I2C_READ_REPLY:
+    {
+      pmt_t rid       = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK);
+      pmt_t i2c_addr  = pmt_from_long((subpkt >> CS_I2CADDR_SHIFT) & CS_I2CADDR_MASK);
+
+      // Make a u8 vector to dump the data from the packet into
+      size_t i2c_data_len;
+      pmt_t i2c_data  = pmt_make_u8vector(len - 2, 0);   // skip rid+mbz+addr = 2 bytes
+      uint8_t *w_data  = 
+          (uint8_t *) pmt_u8vector_writeable_elements(i2c_data, i2c_data_len);
+
+      memcpy(w_data, d_payload + payload_offset + 4, i2c_data_len);  // skip first word
+
+      return pmt_list4(s_op_i2c_read_reply, rid, i2c_addr, i2c_data);
+    }
+
+    case OP_SPI_READ_REPLY:
+    {
+      pmt_t rid       = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK);
+      
+      // Make a u8 vector to dump the data from the packet into
+      size_t spi_data_len;
+      pmt_t spi_data  = pmt_make_u8vector(len - 2, 0);   // skip rid+mbz+addr = 2 bytes
+      uint8_t *w_data  = 
+          (uint8_t *) pmt_u8vector_writeable_elements(spi_data, spi_data_len);
+
+      memcpy(w_data, d_payload + payload_offset + 4, spi_data_len);  // skip first word
+
+      return pmt_list3(s_op_spi_read_reply, rid, spi_data);
+    }
+
+    case OP_PING_FIXED:
+    {
+      pmt_t rid     = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK);
+      pmt_t pingval = pmt_from_long((subpkt >> CS_PINGVAL_SHIFT) & CS_PINGVAL_MASK);
+      return pmt_list3(s_op_ping_fixed, rid, pingval);
+    }
+
+    case OP_WRITE_REG:
+    {
+      pmt_t reg_num = pmt_from_long((subpkt >> CS_REGNUM_SHIFT) & CS_REGNUM_MASK);
+
+      // To get the register value we just read the next 32 bits
+      uint32_t val  = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4)));
+      pmt_t reg_val = pmt_from_long(val);
+
+      return pmt_list3(s_op_write_reg, reg_num, reg_val);
+    }
+
+    case OP_WRITE_REG_MASKED:
+    {
+      pmt_t reg_num = pmt_from_long((subpkt >> CS_REGNUM_SHIFT) & CS_REGNUM_MASK);
+
+      // To get the register value we just read the next 32 bits
+      uint32_t val  = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4)));
+      pmt_t reg_val = pmt_from_long(val);
+
+      // The mask is the next 32 bits
+      uint32_t mask  = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 8)));
+      pmt_t reg_mask = pmt_from_long(mask);
+
+      return pmt_list4(s_op_write_reg_masked, reg_num, reg_val, reg_mask);
+    }
+
+    case OP_READ_REG:
+    {
+      pmt_t rid     = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK);
+      pmt_t reg_num = pmt_from_long((subpkt >> CS_REGNUM_SHIFT) & CS_REGNUM_MASK);
+
+      return pmt_list3(s_op_read_reg, rid, reg_num);
+    }
+
+    case OP_I2C_WRITE:
+    {
+      pmt_t i2c_addr    = pmt_from_long((subpkt >> CS_I2CADDR_SHIFT) & CS_I2CADDR_MASK);
+
+      // The length includes an extra 2 bytes for storing the mbz and addr
+      pmt_t i2c_data    = pmt_make_u8vector(len-2, 0);
+
+      // Get a writeable address to copy the data from the packet
+      size_t ignore;
+      uint8_t *w_data = (uint8_t *) pmt_u8vector_writeable_elements(i2c_data, ignore);
+      memcpy(w_data, d_payload + payload_offset + 4, len-2);
+
+      
+      return pmt_list3(s_op_i2c_write, i2c_addr, i2c_data);
+    }
+
+    case OP_I2C_READ:
+    {
+      pmt_t rid       = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK);
+      pmt_t i2c_addr  = pmt_from_long((subpkt >> CS_I2CADDR_SHIFT) & CS_I2CADDR_MASK);
+      
+      // The number of bytes is in the next word
+      uint32_t bytes  = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4)));
+      bytes = (bytes >> CS_I2CREADBYTES_SHIFT) & CS_I2CREADBYTES_MASK;
+      pmt_t i2c_bytes = pmt_from_long(bytes);
+
+      return pmt_list4(s_op_i2c_read, rid, i2c_addr, i2c_bytes);
+    }
+
+    case OP_SPI_WRITE:
+    {
+      // Nothing interesting in the first word, skip to the next
+      uint32_t word  = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4)));
+      pmt_t enables   = pmt_from_long((word >> CS_SPIENABLES_SHIFT) & CS_SPIENABLES_MASK);
+      pmt_t format    = pmt_from_long((word >> CS_SPIFORMAT_SHIFT) & CS_SPIFORMAT_MASK);
+      pmt_t opt       = pmt_from_long((word >> CS_SPIOPT_SHIFT) & CS_SPIOPT_MASK);
+
+      // From the next word and on is data
+      size_t spi_data_len;
+      pmt_t spi_data  = pmt_make_u8vector(len - 6, 0);   // skip rid+mbz+addr = 2 bytes
+      uint8_t *w_data  = 
+          (uint8_t *) pmt_u8vector_writeable_elements(spi_data, spi_data_len);
+
+      memcpy(w_data, d_payload + payload_offset + 8, spi_data_len);  // skip first 2 words
+
+      return pmt_list5(s_op_spi_write, enables, format, opt, spi_data);
+    }
+
+    case OP_SPI_READ:
+    {
+      // Read the RID from the first word, the rest is mbz
+      pmt_t rid       = pmt_from_long((subpkt >> CS_RID_SHIFT) & CS_RID_MASK);
+
+      // Continue at the next word...
+      uint32_t word  = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 4)));
+      pmt_t enables   = pmt_from_long((word >> CS_SPIENABLES_SHIFT) & CS_SPIENABLES_MASK);
+      pmt_t format    = pmt_from_long((word >> CS_SPIFORMAT_SHIFT) & CS_SPIFORMAT_MASK);
+      pmt_t opt       = pmt_from_long((word >> CS_SPIOPT_SHIFT) & CS_SPIOPT_MASK);
+
+      // The number of bytes is the only thing to read in the next word
+      word  = usrp_to_host_u32(*((uint32_t *)(d_payload + payload_offset + 8)));
+      pmt_t n_bytes   = pmt_from_long((word >> CS_SPINBYTES_SHIFT) & CS_SPINBYTES_MASK);
+
+      return pmt_list6(s_op_spi_read, rid, enables, format, opt, n_bytes);
+    }
+
+    case OP_DELAY:
+    {
+      pmt_t ticks = pmt_from_long((subpkt >> CS_DELAY_SHIFT) & CS_DELAY_MASK);
+
+      return pmt_list2(s_op_delay, ticks);
+    }
+    
+    default:
+      return PMT_NIL;
+
+  }
+}
+
diff --git a/usrp/host/lib/inband/usrp_inband_usb_packet.h b/usrp/host/lib/inband/usrp_inband_usb_packet.h
index e22b567fa..9290f55ae 100644
--- a/usrp/host/lib/inband/usrp_inband_usb_packet.h
+++ b/usrp/host/lib/inband/usrp_inband_usb_packet.h
@@ -24,6 +24,10 @@
 
 #include <usrp_bytesex.h>
 #include <mb_mblock.h>
+#include <pmt.h>
+#include <iostream>
+
+#include <symbols_usrp_low_level_cs.h>
 
 static const int USB_PKT_SIZE = 512;   // bytes
 static const int MAX_PAYLOAD = USB_PKT_SIZE-2*sizeof(uint32_t);
@@ -38,12 +42,28 @@ class usrp_inband_usb_packet {
 
 public:
 
+  enum opcodes {
+    OP_PING_FIXED         = 0x00,
+    OP_PING_FIXED_REPLY   = 0x01,
+    OP_WRITE_REG          = 0x02,
+    OP_WRITE_REG_MASKED   = 0x03,
+    OP_READ_REG           = 0x04,
+    OP_READ_REG_REPLY     = 0x05,
+    OP_I2C_WRITE          = 0x06,
+    OP_I2C_READ           = 0x07,
+    OP_I2C_READ_REPLY     = 0x08,
+    OP_SPI_WRITE          = 0x09,
+    OP_SPI_READ           = 0x0a,
+    OP_SPI_READ_REPLY     = 0x0b,
+    OP_DELAY              = 0x0c
+  };
+
   enum flags {
     FL_OVERRUN        = 0x80000000,
     FL_UNDERRUN       = 0x40000000,
     FL_DROPPED        = 0x20000000,
-    FL_END_OF_BURST   = 0x10000000,
-    FL_START_OF_BURST = 0x08000000,
+    FL_START_OF_BURST = 0x10000000,
+    FL_END_OF_BURST   = 0x08000000,
 
     FL_ALL_FLAGS      = 0xf8000000
   };
@@ -51,8 +71,8 @@ public:
   static const int FL_OVERRUN_SHIFT = 31;
   static const int FL_UNDERRUN_SHIFT = 30;
   static const int FL_DROPPED_SHIFT = 29;
-  static const int FL_END_OF_BURST_SHIFT = 28;
-  static const int FL_START_OF_BURST_SHIFT = 27;
+  static const int FL_END_OF_BURST_SHIFT = 27;
+  static const int FL_START_OF_BURST_SHIFT = 28;
   
   static const int RSSI_MASK = 0x3f;
   static const int RSSI_SHIFT = 21;
@@ -66,6 +86,50 @@ public:
   static const int PAYLOAD_LEN_MASK = 0x1ff;
   static const int PAYLOAD_LEN_SHIFT = 0;
 
+  // Fixed size for opcode and length fields
+  static const int CS_FIXED_LEN = 2;
+
+  static const int CS_OPCODE_MASK = 0xff;
+  static const int CS_OPCODE_SHIFT = 24;
+
+  static const int CS_LEN_MASK = 0xff;
+  static const int CS_LEN_SHIFT = 16;
+
+  static const int CS_RID_MASK = 0x3f;
+  static const int CS_RID_SHIFT = 10;
+
+  static const int CS_PING_LEN = 2;
+  static const int CS_PINGVAL_MASK = 0x3ff;
+  static const int CS_PINGVAL_SHIFT = 0;
+
+  static const int CS_WRITEREG_LEN = 6;
+  static const int CS_WRITEREGMASKED_LEN = 10;
+  static const int CS_READREG_LEN = 2;
+  static const int CS_READREGREPLY_LEN = 6;
+  static const int CS_REGNUM_MASK = 0x3ff;
+  static const int CS_REGNUM_SHIFT = 0;
+
+  static const int CS_DELAY_LEN = 2;
+  static const int CS_DELAY_MASK = 0xffff;
+  static const int CS_DELAY_SHIFT = 0;
+
+  static const int CS_I2CADDR_MASK = 0x7f;
+  static const int CS_I2CADDR_SHIFT = 0;
+
+  static const int CS_I2CREAD_LEN = 3;
+  static const int CS_I2CREADBYTES_MASK = 0x7f;
+  static const int CS_I2CREADBYTES_SHIFT = 24;
+
+  static const int CS_SPIOPT_MASK = 0xffff;
+  static const int CS_SPIOPT_SHIFT = 0;
+  static const int CS_SPIFORMAT_MASK = 0xff;
+  static const int CS_SPIFORMAT_SHIFT = 16;
+  static const int CS_SPIENABLES_MASK = 0xff;
+  static const int CS_SPIENABLES_SHIFT = 24;
+  static const int CS_SPIREAD_LEN = 7;
+  static const int CS_SPINBYTES_MASK = 0xff;
+  static const int CS_SPINBYTES_SHIFT = 24;
+
 public:
   
   void set_timestamp(uint32_t timestamp){
@@ -77,7 +141,7 @@ public:
     word0 |= 1<<FL_END_OF_BURST_SHIFT;
     d_word0 = host_to_usrp_u32(word0);
   }
-
+  
   void set_header(int flags, int chan, int tag, int payload_len){
     uint32_t word0 =  ((flags & FL_ALL_FLAGS)
                        | ((chan & CHAN_MASK) << CHAN_SHIFT)
@@ -144,6 +208,27 @@ public:
     return MAX_PAYLOAD;
   }
 
+  static int max_pkt_size() {
+    return USB_PKT_SIZE;
+  }
+
+  // C/S methods
+  bool align32();
+  bool cs_ping(long rid, long ping_val);
+  bool cs_ping_reply(long rid, long ping_val);
+  bool cs_write_reg(long reg_num, long val);
+  bool cs_write_reg_masked(long reg_num, long val, long mask);
+  bool cs_read_reg(long rid, long reg_num);
+  bool cs_read_reg_reply(long rid, long reg_num, long reg_val);
+  bool cs_delay(long ticks);
+  bool cs_i2c_write(long i2c_addr, uint8_t *i2c_data, size_t data_len);
+  bool cs_i2c_read(long rid, long i2c_addr, long n_bytes);
+  bool cs_i2c_read_reply(long rid, long i2c_addr, uint8_t *i2c_data, long i2c_data_len);
+  bool cs_spi_write(long enables, long format, long opt_header_bytes, uint8_t *spi_data, long spi_data_len);
+  bool cs_spi_read(long rid, long enables, long format, long opt_header_bytes, long n_bytes);
+  bool cs_spi_read_reply(long rid, uint8_t *spi_data, long spi_data_len);
+  int cs_len(int payload_offset);
+  pmt_t read_subpacket(int payload_offset);
 };
 
 #endif
diff --git a/usrp/host/lib/inband/usrp_interface.mbh b/usrp/host/lib/inband/usrp_interface.mbh
new file mode 100644
index 000000000..ad0f78b4e
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_interface.mbh
@@ -0,0 +1,88 @@
+;; -*- scheme -*- ; not really, but tells emacs how to format this
+;;
+;; Copyright 2007 Free Software Foundation, Inc.
+;; 
+;; This file is part of GNU Radio
+;; 
+;; GNU Radio is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+;; 
+;; GNU Radio is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;; 
+;; You should have received a copy of the GNU General Public License along
+;; with this program; if not, write to the Free Software Foundation, Inc.,
+;; 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+;;
+
+;; ----------------------------------------------------------------
+;;              This is an mblock header file
+;;
+;; The format is very much a work-in-progress.
+;; It'll be compiled to C++.
+;; ----------------------------------------------------------------
+
+;; ----------------------------------------------------------------
+;; usrp-interface-cs
+;;
+;; Handles interaction between the usrp_sever and the USB interface
+
+(define-protocol-class usrp-interface-cs
+
+  (:outgoing
+   (cmd-usrp-open invocation-handle which-usrp)
+   (cmd-usrp-close invocation-handle)
+   (cmd-usrp-ntx-chan invocation-handle)
+   (cmd-usrp-nrx-chan invocation-handle)
+   (cmd-usrp-write invocation-handle channel data)
+   (cmd-usrp-start-reading invocation-handle channel)
+   )
+
+  (:incoming
+   (response-usrp-open invocation-handle status)
+   (response-usrp-close invocation-handle status)
+   (response-usrp-ntx-chan invocation-handle ntx-chan)
+   (response-usrp-nrx-chan invocation-handle nrx-chan)
+   (response-usrp-write invocation-handle status channel)
+   (response-usrp-read invocation-handle status data)
+   )
+  )
+
+;; ----------------------------------------------------------------
+;; usrp-tx-cs
+;;
+;; Handles interaction between the USB interface and TX interface
+
+(define-protocol-class usrp-tx-cs
+
+  (:outgoing
+   (cmd-usrp-tx-write invocation-handle channel data tx-handle)
+   )
+
+  (:incoming
+   (response-usrp-tx-write invocation-handle status channel)
+   )
+  )
+
+;; ----------------------------------------------------------------
+;; usrp-rx-cs
+;;
+;; Handles interaction between the USB interface and RX interface
+
+(define-protocol-class usrp-rx-cs
+
+  (:outgoing
+   (cmd-usrp-rx-start-reading invocation-handle rx-handle)
+   (cmd-usrp-rx-stop-reading invocation-handle)
+   )
+
+  (:incoming
+   (response-usrp-rx-read invocation-handle status data)
+
+   ;; There is currently no response to a stop reading
+   )
+  )
diff --git a/usrp/host/lib/inband/usrp_rx.cc b/usrp/host/lib/inband/usrp_rx.cc
new file mode 100644
index 000000000..7344a6e89
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_rx.cc
@@ -0,0 +1,142 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <usrp_rx.h>
+
+#include <usrp_standard.h>
+#include <iostream>
+#include <vector>
+#include <usb.h>
+#include <mb_class_registry.h>
+#include <usrp_inband_usb_packet.h>
+#include <fpga_regs_common.h>
+#include <stdio.h>
+
+#include <symbols_usrp_rx_cs.h>
+
+typedef usrp_inband_usb_packet transport_pkt;
+
+static const bool verbose = false;
+
+usrp_rx::usrp_rx(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(rt, instance_name, user_arg),
+    d_disk_write(false)
+{
+  d_cs = define_port("cs", "usrp-rx-cs", true, mb_port::EXTERNAL);
+  
+  //d_disk_write=true;
+  
+  if(d_disk_write) {
+    d_ofile.open("rx_data.dat",std::ios::binary|std::ios::out);
+    d_cs_ofile.open("rx_cs.dat",std::ios::binary|std::ios::out);
+  }
+
+}
+
+usrp_rx::~usrp_rx() 
+{
+  if(d_disk_write) {
+    d_ofile.close();
+    d_cs_ofile.close();
+  }
+}
+
+void 
+usrp_rx::initial_transition()
+{
+  
+}
+
+void
+usrp_rx::handle_message(mb_message_sptr msg)
+{
+  pmt_t event = msg->signal();
+  pmt_t port_id = msg->port_id();
+  pmt_t data = msg->data(); 
+
+  // Theoretically only have 1 message to ever expect, but
+  // want to make sure its at least what we want
+  if(pmt_eq(port_id, d_cs->port_symbol())) {
+    
+    if(pmt_eqv(event, s_cmd_usrp_rx_start_reading))
+      read_and_respond(data);
+  }
+}
+
+void
+usrp_rx::read_and_respond(pmt_t data)
+{
+  size_t ignore;
+  bool underrun;
+  unsigned int n_read;
+  unsigned int pkt_size = sizeof(transport_pkt);
+
+  pmt_t invocation_handle = pmt_nth(0, data);
+
+  // Need the handle to the RX port to send responses, this is passed
+  // by the USRP interface m-block
+  d_urx = 
+    boost::any_cast<usrp_standard_rx *>(pmt_any_ref(pmt_nth(1, data)));
+
+  if(verbose)
+    std::cout << "[usrp_rx] Waiting for packets..\n";
+
+  // Read by 512 which is packet size and send them back up
+  while(1) {
+
+    pmt_t v_pkt = pmt_make_u8vector(pkt_size, 0);
+    transport_pkt *pkt = 
+      (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, ignore);
+
+    n_read = d_urx->read(pkt, pkt_size, &underrun);
+
+    if(n_read != pkt_size) {
+      std::cerr << "[usrp_rx] Error reading packet, shutting down\n";
+      d_cs->send(s_response_usrp_rx_read, 
+                 pmt_list3(PMT_NIL, PMT_F, PMT_NIL));
+      return;
+    }
+
+    if(underrun)
+      std::cout << "[usrp_rx] Underrun\n";
+
+    d_cs->send(s_response_usrp_rx_read, 
+               pmt_list3(PMT_NIL, PMT_T, v_pkt));
+    if(verbose)
+      std::cout << "[usrp_rx] Read 1 packet\n";
+    
+    if(d_disk_write) {
+      if(pkt->chan() == 0x1f)
+        d_cs_ofile.write((const char *)pkt, transport_pkt::max_pkt_size());
+      else
+        d_ofile.write((const char *)pkt, transport_pkt::max_pkt_size());
+
+      d_cs_ofile.flush();
+      d_ofile.flush();
+    }
+  }
+}
+
+REGISTER_MBLOCK_CLASS(usrp_rx);
diff --git a/usrp/host/lib/inband/usrp_rx.h b/usrp/host/lib/inband/usrp_rx.h
new file mode 100644
index 000000000..e1a90a781
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_rx.h
@@ -0,0 +1,55 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_USRP_RX_H
+#define INCLUDED_USRP_RX_H
+
+#include <mb_mblock.h>
+#include <fstream>
+
+class usrp_standard_rx;
+
+/*!
+ * \brief Implements the low level usb interface to the USRP
+ */
+class usrp_rx : public mb_mblock
+{
+  mb_port_sptr		d_cs;
+  usrp_standard_rx     *d_urx;
+  
+  bool d_disk_write;
+  std::ofstream d_ofile;
+  std::ofstream d_cs_ofile;
+  
+ public:
+  usrp_rx(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg);
+  ~usrp_rx();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ private:
+  void read_and_respond(pmt_t data);
+  void read_data();
+ 
+};
+  
+
+#endif /* INCLUDED_USRP_RX_H */
+
diff --git a/usrp/host/lib/inband/usrp_rx_stub.cc b/usrp/host/lib/inband/usrp_rx_stub.cc
new file mode 100644
index 000000000..bf78ddf27
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_rx_stub.cc
@@ -0,0 +1,183 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <usrp_rx_stub.h>
+
+#include <iostream>
+#include <vector>
+#include <usb.h>
+#include <mb_class_registry.h>
+#include <usrp_inband_usb_packet.h>
+#include <fpga_regs_common.h>
+#include "usrp_standard.h"
+#include <stdio.h>
+#include "ui_nco.h"
+#include <fstream>
+
+#include <symbols_usrp_rx_cs.h>
+
+typedef usrp_inband_usb_packet transport_pkt;
+
+static const bool verbose = false;
+
+bool usrp_rx_stop;
+
+// Used for the fake control packet response code to send the responses back up
+// the RX.  The TX stub dumps responses in to this queue.
+std::queue<pmt_t> d_cs_queue;
+
+usrp_rx_stub::usrp_rx_stub(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(rt, instance_name, user_arg),
+    d_samples_per_frame((long)(126)),
+    d_amplitude(16384),
+    d_disk_write(false)
+{
+  d_cs = define_port("cs", "usrp-rx-cs", true, mb_port::EXTERNAL);
+  
+  // initialize NCO
+  double freq = 100e3;
+  int interp = 32;			    // 32 -> 4MS/s
+  double sample_rate = 128e6 / interp;	
+  d_nco.set_freq(2*M_PI * freq/sample_rate);
+
+  //d_disk_write = true;
+  
+  if(d_disk_write)
+    d_ofile.open("raw_rx.dat",std::ios::binary|std::ios::out);
+  
+  usrp_rx_stop = false;
+}
+
+usrp_rx_stub::~usrp_rx_stub() 
+{
+  if(d_disk_write)
+    d_ofile.close();
+}
+
+void 
+usrp_rx_stub::initial_transition()
+{
+  
+}
+
+void
+usrp_rx_stub::handle_message(mb_message_sptr msg)
+{
+  pmt_t event = msg->signal();
+  pmt_t port_id = msg->port_id();
+  pmt_t data = msg->data(); 
+
+  // Theoretically only have 1 message to ever expect, but
+  // want to make sure its at least what we want
+  if(pmt_eq(port_id, d_cs->port_symbol())) {
+
+    if(verbose)
+      std::cout << "[USRP_RX_STUB] Starting...\n";
+    
+    if(pmt_eqv(event, s_cmd_usrp_rx_start_reading))
+      read_and_respond(data);
+  }
+}
+
+void
+usrp_rx_stub::read_and_respond(pmt_t data)
+{
+
+  while(!usrp_rx_stop) {
+
+    long nsamples_this_frame = d_samples_per_frame;
+
+    size_t nshorts = 2 * nsamples_this_frame;	// 16-bit I & Q
+    long channel = 0;
+    long n_bytes = nshorts*2;
+    pmt_t uvec = pmt_make_s16vector(nshorts, 0);
+    size_t ignore;
+    int16_t *samples = pmt_s16vector_writeable_elements(uvec, ignore);
+
+    // fill in the complex sinusoid
+
+    for (int i = 0; i < nsamples_this_frame; i++){
+
+      if (1){
+        gr_complex s;
+        d_nco.sincos(&s, 1, d_amplitude);
+        // write 16-bit i & q
+        samples[2*i] =   (int16_t) s.real();
+        samples[2*i+1] = (int16_t) s.imag();
+      }
+      else {
+        gr_complex s(d_amplitude, d_amplitude);
+
+        // write 16-bit i & q
+        samples[2*i] =   (int16_t) s.real();
+        samples[2*i+1] = (int16_t) s.imag();
+      }
+    }
+    
+    if(d_disk_write)
+      d_ofile.write((const char *)samples, n_bytes);
+  
+    pmt_t v_pkt = pmt_make_u8vector(sizeof(transport_pkt), 0);
+    transport_pkt *pkt =
+      (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, ignore);
+
+    pkt->set_header(0, channel, 0, n_bytes);
+    pkt->set_timestamp(0xffffffff);
+    memcpy(pkt->payload(), samples, n_bytes);
+    
+    d_cs->send(s_response_usrp_rx_read, pmt_list3(PMT_NIL, PMT_T, v_pkt));
+
+    // Now lets check the shared CS queue between the TX and RX stub.  Each
+    // element in a queue is a list where the first element is an invocation
+    // handle and the second element is a PMT u8 vect representation of the
+    // CS packet response which can just be passed transparently.
+    while(!d_cs_queue.empty()) {
+      
+      pmt_t cs_pkt = d_cs_queue.front();
+      d_cs_queue.pop();
+
+      pmt_t invocation_handle = pmt_nth(0, cs_pkt);
+      pmt_t v_pkt = pmt_nth(1, cs_pkt);
+
+      d_cs->send(s_response_usrp_rx_read,   
+                 pmt_list3(invocation_handle, 
+                           PMT_T, 
+                           v_pkt));  // Take the front CS pkt
+
+      
+      if(verbose)
+        std::cout << "[USRP_RX_STUB] Received CS response from TX stub\n";
+    }
+
+  }
+  
+  usrp_rx_stop = false;
+
+  if(verbose)
+    std::cout << "[USRP_RX_STUB] Got fake RX stop\n";
+
+}
+
+REGISTER_MBLOCK_CLASS(usrp_rx_stub);
diff --git a/usrp/host/lib/inband/usrp_rx_stub.h b/usrp/host/lib/inband/usrp_rx_stub.h
new file mode 100644
index 000000000..483af5b48
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_rx_stub.h
@@ -0,0 +1,71 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_USRP_RX_STUB_H
+#define INCLUDED_USRP_RX_STUB_H
+
+#include <mb_mblock.h>
+#include <vector>
+#include "usrp_standard.h"
+#include "ui_nco.h"
+#include <fstream>
+#include <queue>
+#include <usrp_inband_usb_packet.h>
+
+typedef usrp_inband_usb_packet transport_pkt;
+
+extern bool usrp_rx_stop;   // used to communicate a 'stop' to the RX stub
+extern std::queue<pmt_t> d_cs_queue;
+
+/*!
+ * \brief Implements the low level usb interface to the USRP
+ */
+class usrp_rx_stub : public mb_mblock
+{
+ public:
+
+  mb_port_sptr	d_cs;
+  usrp_standard_rx* d_urx;
+  
+  long		d_samples_per_frame;
+  
+  // for generating sine wave output
+  ui_nco<float,float>	d_nco;
+  double	        d_amplitude;
+
+  bool d_disk_write;
+
+  std::ofstream d_ofile;
+  
+ public:
+  usrp_rx_stub(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg);
+  ~usrp_rx_stub();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ private:
+  void read_and_respond(pmt_t data);
+  void read_data();
+ 
+};
+  
+
+#endif /* INCLUDED_USRP_RX_H */
+
diff --git a/usrp/host/lib/inband/usrp_server.cc b/usrp/host/lib/inband/usrp_server.cc
index 800bf0e15..760397dc7 100644
--- a/usrp/host/lib/inband/usrp_server.cc
+++ b/usrp/host/lib/inband/usrp_server.cc
@@ -27,39 +27,19 @@
 #include <usrp_inband_usb_packet.h>
 #include <mb_class_registry.h>
 #include <vector>
+#include <usrp_usb_interface.h>
+
+#include <symbols_usrp_server_cs.h>
+#include <symbols_usrp_channel.h>
+#include <symbols_usrp_tx.h>
+#include <symbols_usrp_rx.h>
+#include <symbols_usrp_low_level_cs.h>
+#include <symbols_usrp_interface_cs.h>
+static pmt_t s_shutdown = pmt_intern("%shutdown");
 
 typedef usrp_inband_usb_packet transport_pkt;   // makes conversion to gigabit easy
 
-// FIXME We should machine generate these by a simple preprocessor run over this file
-//
-// These are all the messages that we expect to receive.
-//
-// We "intern" these here (make them into symbols) so that our
-// comparisions below are effectively pointer comparisons.
-
-static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel");
-static pmt_t s_cmd_close = pmt_intern("cmd-close");
-static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel");
-static pmt_t s_cmd_open = pmt_intern("cmd-open");
-static pmt_t s_cmd_start_recv_raw_samples = pmt_intern("cmd-start-recv-raw-samples");
-static pmt_t s_cmd_stop_recv_raw_samples = pmt_intern("cmd-stop-recv-raw-samples");
-static pmt_t s_cmd_to_control_channel = pmt_intern("cmd-to-control-channel");
-static pmt_t s_cmd_xmit_raw_frame  = pmt_intern("cmd-xmit-raw-frame");
-static pmt_t s_cmd_max_capacity  = pmt_intern("cmd-max-capacity");
-static pmt_t s_cmd_ntx_chan  = pmt_intern("cmd-ntx-chan");
-static pmt_t s_cmd_nrx_chan  = pmt_intern("cmd-nrx-chan");
-static pmt_t s_cmd_current_capacity_allocation  = pmt_intern("cmd-current-capacity-allocation");
-static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel");
-static pmt_t s_response_close = pmt_intern("response-close");
-static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel");
-static pmt_t s_response_from_control_channel = pmt_intern("response-from-control-channel");
-static pmt_t s_response_open = pmt_intern("response-open");
-static pmt_t s_response_recv_raw_samples = pmt_intern("response-recv-raw-samples");
-static pmt_t s_response_xmit_raw_frame = pmt_intern("response-xmit-raw-frame");
-static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity");
-static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan");
-static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan");
-static pmt_t s_response_current_capacity_allocation  = pmt_intern("response-current-capacity-allocation");
+const static bool verbose = false;
 
 static std::string
 str(long x)
@@ -70,36 +50,75 @@ str(long x)
 }
 
 usrp_server::usrp_server(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg)
-  : mb_mblock(rt, instance_name, user_arg)
+  : mb_mblock(rt, instance_name, user_arg),
+  d_fake_rx(false)
 {
-  // define our ports
 
+  // Dictionary for arguments to all of the components
+  pmt_t usrp_dict = user_arg;
+  
   // control & status port
   d_cs = define_port("cs", "usrp-server-cs", true, mb_port::EXTERNAL);	
+  d_cs_usrp = define_port("cs_usrp", "usrp-interface-cs", false, mb_port::INTERNAL);	
 
   // ports
   //
   // (if/when we do replicated ports, these will be replaced by a
   //  single replicated port)
   for(int port=0; port < N_PORTS; port++) {
-    d_tx.push_back(define_port("tx"+str(port), "usrp-tx", true, mb_port::EXTERNAL));
-    d_rx.push_back(define_port("rx"+str(port), "usrp-rx", true, mb_port::EXTERNAL));
+
+    d_tx.push_back(define_port("tx"+str(port), 
+                               "usrp-tx", 
+                               true, 
+                               mb_port::EXTERNAL));
+
+    d_rx.push_back(define_port("rx"+str(port), 
+                               "usrp-rx", 
+                               true, 
+                               mb_port::EXTERNAL));
   }
 
-  // FIXME ... initializing to 2 channels on each for now, eventually we should
-  // query the FPGA to get these values
-  d_ntx_chan = 2;
+  define_component("usrp", "usrp_usb_interface", usrp_dict);
+  connect("self", "cs_usrp", "usrp", "cs");
+
+  d_defer=false;
+  d_opened=false;
+
+  // FIXME: needs to be returned from open, if we want to use this
   d_nrx_chan = 2;
+  d_ntx_chan = 2;
 
   // Initialize capacity on each channel to 0 and to no owner
+  // Also initialize the USRP standard tx/rx pointers to NULL
+  for(int chan=0; chan < d_ntx_chan; chan++)
+    d_chaninfo_tx.push_back(channel_info());
+
+  for(int chan=0; chan < d_nrx_chan; chan++)
+    d_chaninfo_rx.push_back(channel_info());
+
+  d_rx_chan_mask = 0;
+
+  for(int i=0; i < D_MAX_RID; i++) 
+    d_rids.push_back(rid_info());
+
+  //d_fake_rx=true;
+}
+
+void
+usrp_server::reset_channels()
+{
+
   for(int chan=0; chan < d_ntx_chan; chan++) {
     d_chaninfo_tx[chan].assigned_capacity = 0;
     d_chaninfo_tx[chan].owner = PMT_NIL;
   }
+
   for(int chan=0; chan < d_nrx_chan; chan++) {
     d_chaninfo_rx[chan].assigned_capacity = 0;
     d_chaninfo_rx[chan].owner = PMT_NIL;
   }
+
+  d_rx_chan_mask = 0;
 }
 
 usrp_server::~usrp_server()
@@ -119,78 +138,328 @@ usrp_server::handle_message(mb_message_sptr msg)
   pmt_t event = msg->signal();		// the "name" of the message
   pmt_t port_id = msg->port_id();	// which port it came in on
   pmt_t data = msg->data();
-  pmt_t metadata = msg->metadata();
   pmt_t invocation_handle;
-  pmt_t reply_data;
+  pmt_t metadata = msg->metadata();
   pmt_t status;
 
-  if (1){
+  long port;
+
+  if (pmt_eq(event, s_shutdown))	// ignore (for now)
+    return;
+
+  invocation_handle = pmt_nth(0, data);
+
+  if (0){
     std::cout << "[USRP_SERVER] event: " << event << std::endl;
     std::cout << "[USRP_SERVER] port_id: " << port_id << std::endl;
   }
 
-  // It would be nice if this were all table driven, and we could
-  // compute our state transition as f(current_state, port_id, signal)
+  // It would be nice if this were all table driven, and we could compute our
+  // state transition as f(current_state, port_id, signal)
+  
+  // A message from the USRP CS, which should *only* be responses
+  //
+  // It is important that this set come before checking messages of any other
+  // components.  This is since we always want to listen to the low level USRP
+  // server, even if we aren't initialized we are waiting for responses to
+  // become initialized.  Likewise, after the usrp_server is "closed", we still
+  // want to pass responses back from the low level.
 
-  if (pmt_eq(port_id, d_cs->port_symbol())){	// message came in on our control/status port
+  //---------------- USRP RESPONSE ---------------//
+  if (pmt_eq(port_id, d_cs_usrp->port_symbol())) { 
+    
+    //-------------- USRP OPEN ------------------//
+    if(pmt_eq(event, s_response_usrp_open)) {
+      // pass the response back over the regular CS port
+      pmt_t status = pmt_nth(1, data);
+      d_cs->send(s_response_open, pmt_list2(invocation_handle, status));
 
-    if (pmt_eq(event, s_cmd_open)){
-      // extract args from data
-      invocation_handle = pmt_nth(0, data);
-      long which_usrp = pmt_to_long(pmt_nth(1, data));	// integer usrp id, usually 0
+      if(pmt_eqv(status,PMT_T)) {
+        d_opened = true;
+        d_defer = false;
+        recall_defer_queue();
+      }
+
+      return;
+    }
+    //------------- USRP CLOSE -------------------//
+    else if (pmt_eq(event, s_response_usrp_close)) {
+      pmt_t status = pmt_nth(1, data);
+      d_cs->send(s_response_close, pmt_list2(invocation_handle, status));
+
+      if(pmt_eqv(status,PMT_T)) {
+        d_opened = false;
+        d_defer = false;
+        reset_channels();
+        recall_defer_queue();
+      }
       
-      // Do the right thing....
-      // build a reply
-      (void) which_usrp;	// avoid unused warning
+      return;
+    }
+    //--------------- USRP WRITE --------------//
+    else if (pmt_eq(event, s_response_usrp_write)) {
+      
+      pmt_t status = pmt_nth(1, data);
+      long channel = pmt_to_long(pmt_nth(2, data));
+      long port;
+
+      // Do not report back responses if they were generated from a
+      // command packet
+      if(channel == 0x1f)
+        return;
+
+      // Find the port through the owner of the channel
+      if((port = tx_port_index(d_chaninfo_tx[channel].owner)) !=-1 )
+        d_tx[port]->send(s_response_xmit_raw_frame, 
+                         pmt_list2(invocation_handle, status));
+      return;
+    }
+    //--------------- USRP READ ---------------//
+    else if (pmt_eq(event, s_response_usrp_read)) {
+
+      pmt_t status = pmt_nth(1, data);
+
+      if(!pmt_eqv(status, PMT_T)) {
+        std::cerr << "[USRP_SERVER] Error receiving packet\n";
+        return;
+      }
+      else {
+        handle_response_usrp_read(data);
+        return;
+      }
+    }
+
+    goto unhandled;
+  }
+
+  // Checking for defer on all other messages
+  if(d_defer) {
+    if (verbose)
+      std::cout << "[USRP_SERVER] Received msg while deferring (" 
+                << msg->signal() << ")\n";
+    d_defer_queue.push(msg);
+    return;
+  }
+  
+  //--------- CONTROL / STATUS ------------//
+  if (pmt_eq(port_id, d_cs->port_symbol())){
+    
+    //----------- OPEN -----------//
+    if (pmt_eq(event, s_cmd_open)){
 
-      // if everything OK
-      status = PMT_T;
-      reply_data = pmt_list2(invocation_handle, status);
+      // Reject if already open
+      if(d_opened) {
+        d_cs->send(s_response_open, pmt_list2(invocation_handle, s_err_usrp_already_opened));
+        return;
+      }
 
-      //  ...and send it
-      d_cs->send(s_response_open, reply_data);
+      // the parameters are the same to the low level interface, so we just pass 'data' along
+      d_cs_usrp->send(s_cmd_usrp_open, data);
+
+      d_defer = true;
+      
       return;
     }
+    //---------- CLOSE -----------//
     else if (pmt_eq(event, s_cmd_close)){
-      // ...
+      
+      if(!d_opened) { 
+        d_cs->send(s_response_close, pmt_list2(invocation_handle, s_err_usrp_already_closed));
+        return;
+      }
+      
+      d_defer = true;
+      d_cs_usrp->send(s_cmd_usrp_close, pmt_list1(invocation_handle));
+
+      return;
     }
+    //---------- MAX CAPACITY ----------//
     else if (pmt_eq(event, s_cmd_max_capacity)) {
-      invocation_handle = pmt_nth(0, data);
-      reply_data = pmt_list2(invocation_handle, pmt_from_long(max_capacity()));
-      d_cs->send(s_response_max_capacity, reply_data);
+      
+      if(!d_opened) { 
+        d_cs->send(s_response_max_capacity, 
+                   pmt_list3(invocation_handle, s_err_usrp_not_opened, pmt_from_long(0)));
+        return;
+      }
+
+      d_cs->send(s_response_max_capacity, 
+                 pmt_list3(invocation_handle, 
+                           PMT_T, 
+                           pmt_from_long(max_capacity())));
       return;
     }
+    //---------- NTX CHAN --------------//
     else if (pmt_eq(event, s_cmd_ntx_chan)) {
-      invocation_handle = pmt_nth(0, data);
-      reply_data = pmt_list2(invocation_handle, pmt_from_long(d_ntx_chan));
-      d_cs->send(s_response_ntx_chan, reply_data);
+
+      if(!d_opened) { 
+        d_cs->send(s_response_ntx_chan, 
+                   pmt_list3(invocation_handle, s_err_usrp_not_opened, pmt_from_long(0)));
+        return;
+      }
+
+      d_cs->send(s_response_ntx_chan, 
+                 pmt_list3(invocation_handle, 
+                           PMT_T, 
+                           pmt_from_long(d_ntx_chan)));
+      return;
     }
+    //---------- NRX CHAN -----------//
     else if (pmt_eq(event, s_cmd_nrx_chan)) {
-      invocation_handle = pmt_nth(0, data);
-      reply_data = pmt_list2(invocation_handle, pmt_from_long(d_nrx_chan));
-      d_cs->send(s_response_nrx_chan, reply_data);
-    }
+
+      if(!d_opened) { 
+        d_cs->send(s_response_nrx_chan, 
+                   pmt_list3(invocation_handle, s_err_usrp_not_opened, pmt_from_long(0)));
+        return;
+      }
+
+      d_cs->send(s_response_nrx_chan, 
+                 pmt_list3(invocation_handle, 
+                           PMT_T, 
+                           pmt_from_long(d_nrx_chan)));
+      return;
+    }	
+    //--------- ALLOCATION? -----------//
     else if (pmt_eq(event, s_cmd_current_capacity_allocation)) {
-      invocation_handle = pmt_nth(0, data);
-      reply_data = pmt_list2(invocation_handle, pmt_from_long(current_capacity_allocation()));
-      d_cs->send(s_response_current_capacity_allocation, reply_data);
+      
+      if(!d_opened) { 
+        d_cs->send(s_response_current_capacity_allocation, 
+                   pmt_list3(invocation_handle, 
+                             s_err_usrp_not_opened, 
+                             pmt_from_long(0)));
+        return;
+      }
+      
+      d_cs->send(s_response_current_capacity_allocation, 
+                 pmt_list3(invocation_handle, 
+                           PMT_T, 
+                           pmt_from_long(current_capacity_allocation())));
+      return;
     }
     goto unhandled;
   }
+  
+  //-------------- TX ---------------//
+  if ((port = tx_port_index(port_id)) != -1) {
+    
+    //------------ ALLOCATE (TX) ----------------//
+    if (pmt_eq(event, s_cmd_allocate_channel)){
+      
+      if(!d_opened) { 
+        d_tx[port]->send(s_response_allocate_channel, 
+                          pmt_list3(invocation_handle, 
+                                    s_err_usrp_not_opened, 
+                                    pmt_from_long(0)));
+        return;
+      }
+        
+      handle_cmd_allocate_channel(d_tx[port], d_chaninfo_tx, data);
+      return;
+    }
+  
+    //----------- DEALLOCATE (TX) ---------------//
+    if (pmt_eq(event, s_cmd_deallocate_channel)) {
+    
+      if(!d_opened) {
+        d_tx[port]->send(s_response_deallocate_channel, 
+                         pmt_list3(invocation_handle, 
+                                   s_err_usrp_not_opened, 
+                                   pmt_from_long(0)));
+        return;
+      }
 
-  if (pmt_eq(event, s_cmd_allocate_channel)){
-    handle_cmd_allocate_channel(port_id, data);
-    return;
-  }
+      handle_cmd_deallocate_channel(d_tx[port], d_chaninfo_tx, data);
+      return;
+    }
+  
+    //-------------- XMIT RAW FRAME -----------------/
+    if (pmt_eq(event, s_cmd_xmit_raw_frame)){
 
-  if (pmt_eq(event, s_cmd_deallocate_channel)) {
-    handle_cmd_deallocate_channel(port_id, data);
-    return;
+      if(!d_opened) { 
+        d_tx[port]->send(s_response_xmit_raw_frame, 
+                         pmt_list2(invocation_handle, s_err_usrp_not_opened));
+        return;
+      }
+      
+      handle_cmd_xmit_raw_frame(d_tx[port], d_chaninfo_tx, data);
+      return;
+    }
+    
+    //-------------- CONTROL PACKET -----------------/
+    if (pmt_eq(event, s_cmd_to_control_channel)) {
+      
+      if(!d_opened) { 
+        d_tx[port]->send(s_response_xmit_raw_frame, 
+                         pmt_list2(invocation_handle, s_err_usrp_not_opened));
+        return;
+      }
+      
+      handle_cmd_to_control_channel(d_tx[port], d_chaninfo_tx, data);
+      return;
+
+    }
+
+    goto unhandled;
   }
+
+  //-------------- RX ---------------//
+  if ((port = rx_port_index(port_id)) != -1) {
     
-  if (pmt_eq(event, s_cmd_xmit_raw_frame)){
-    handle_cmd_xmit_raw_frame(data);
-    return;
+    //------------ ALLOCATE (RX) ----------------//
+    if (pmt_eq(event, s_cmd_allocate_channel)) {
+      
+      if(!d_opened) { 
+        d_rx[port]->send(s_response_allocate_channel, 
+                          pmt_list3(invocation_handle, 
+                                    s_err_usrp_not_opened, 
+                                    pmt_from_long(0)));
+        return;
+      }
+        
+      handle_cmd_allocate_channel(d_rx[port], d_chaninfo_rx, data);
+      return;
+    }
+  
+    //----------- DEALLOCATE (RX) ---------------//
+    if (pmt_eq(event, s_cmd_deallocate_channel)) {
+    
+      if(!d_opened) {
+        d_rx[port]->send(s_response_deallocate_channel, 
+                         pmt_list3(invocation_handle, 
+                                   s_err_usrp_not_opened, 
+                                   pmt_from_long(0)));
+        return;
+      }
+
+      handle_cmd_deallocate_channel(d_rx[port], d_chaninfo_rx, data);
+      return;
+    }
+  
+    //-------------- START RECV ----------------//
+    if (pmt_eq(event, s_cmd_start_recv_raw_samples)) {
+    
+      if(!d_opened) {
+        d_rx[port]->send(s_response_recv_raw_samples,
+                         pmt_list2(invocation_handle, s_err_usrp_not_opened));
+        return;
+      }
+
+      handle_cmd_start_recv_raw_samples(d_rx[port], d_chaninfo_rx, data);
+      return;
+    }
+    
+    //-------------- STOP RECV ----------------//
+    if (pmt_eq(event, s_cmd_stop_recv_raw_samples)) {
+    
+      if(!d_opened) 
+        return;
+
+      // FIX ME : no response for stopping? even if error? (permissions)
+      handle_cmd_stop_recv_raw_samples(d_rx[port], d_chaninfo_rx, data);
+
+      return;
+    }
+
+    goto unhandled;
   }
 
  unhandled:
@@ -231,128 +500,94 @@ long usrp_server::current_capacity_allocation() {
   return capacity;
 }
     
-void usrp_server::handle_cmd_allocate_channel(pmt_t port_id, pmt_t data) {
-
+void 
+usrp_server::handle_cmd_allocate_channel(
+                                mb_port_sptr port, 
+                                std::vector<struct channel_info> &chan_info,
+                                pmt_t data)
+{
   pmt_t invocation_handle = pmt_nth(0, data);
   long rqstd_capacity = pmt_to_long(pmt_nth(1, data));
-  long chan, port;
-  pmt_t reply_data;
+  long chan;
 
-  // If it's a TX port, allocate on a free channel, else check if it's a RX port
-  // and allocate.
-  if((port = tx_port_index(port_id)) != -1) {
+  // Check capacity exists
+  if((D_USB_CAPACITY - current_capacity_allocation()) < rqstd_capacity) {
 
-    // Check capacity exists
-    if((D_USB_CAPACITY - current_capacity_allocation()) < rqstd_capacity) {
-      reply_data = pmt_list3(invocation_handle, pmt_from_long(RQSTD_CAPACITY_UNAVAIL), PMT_NIL);  // no capacity available
-      d_tx[port]->send(s_response_allocate_channel, reply_data);
-      return;
-    }
+    // no capacity available
+    port->send(s_response_allocate_channel, 
+               pmt_list3(invocation_handle, 
+                         s_err_requested_capacity_unavailable, 
+                         PMT_NIL));
+    return;
+  }
 
-    // Find a free channel, assign the capacity and respond
-    for(chan=0; chan < d_ntx_chan; chan++) {
-      if(d_chaninfo_tx[chan].owner == PMT_NIL) {
-        d_chaninfo_tx[chan].owner = port_id;
-        d_chaninfo_tx[chan].assigned_capacity = rqstd_capacity;
-        reply_data = pmt_list3(invocation_handle, PMT_T, pmt_from_long(chan));
-        d_tx[port]->send(s_response_allocate_channel, reply_data);
-        return;
-      }
-    }
+  // Find a free channel, assign the capacity and respond
+  for(chan=0; chan < (long)chan_info.size(); chan++) {
 
-    std::cout << "[USRP_SERVER] Couldnt find a TX chan\n";
+    if(verbose)
+      std::cout << "[USRP_SERVER] Checking chan: " << chan
+                << " owner " << chan_info[chan].owner
+                << " size " << chan_info.size()
+                << std::endl;
 
-    reply_data = pmt_list3(invocation_handle, pmt_from_long(CHANNEL_UNAVAIL), PMT_NIL);  // no free TX chan found
-    d_tx[port]->send(s_response_allocate_channel, reply_data);
-    return;
-  }
+    if(chan_info[chan].owner == PMT_NIL) {
   
-  // Repeat the same process on the RX side if the port was not determined to be TX
-  if((port = rx_port_index(port_id)) != -1) {
-    
-    if((D_USB_CAPACITY - current_capacity_allocation()) < rqstd_capacity) {
-      reply_data = pmt_list3(invocation_handle, pmt_from_long(RQSTD_CAPACITY_UNAVAIL), PMT_NIL);  // no capacity available
-      d_rx[port]->send(s_response_allocate_channel, reply_data);
+      chan_info[chan].owner = port->port_symbol();
+      chan_info[chan].assigned_capacity = rqstd_capacity;
+      
+      port->send(s_response_allocate_channel, 
+                 pmt_list3(invocation_handle, 
+                           PMT_T, 
+                           pmt_from_long(chan)));
+
+      if(verbose)
+        std::cout << "[USRP_SERVER] Assigning channel: " << chan 
+                  << " to " << chan_info[chan].owner
+                  << std::endl;
       return;
     }
+  
+  }
 
-    for(chan=0; chan < d_nrx_chan; chan++) {
-      if(d_chaninfo_rx[chan].owner == PMT_NIL) {
-        d_chaninfo_rx[chan].owner = port_id;
-        d_chaninfo_rx[chan].assigned_capacity = rqstd_capacity;
-        reply_data = pmt_list3(invocation_handle, PMT_T, pmt_from_long(chan));
-        d_rx[port]->send(s_response_allocate_channel, reply_data);
-        return;
-      }
-    }
+  if (verbose)
+    std::cout << "[USRP_SERVER] Couldnt find a TX chan\n";
 
-    std::cout << "[USRP_SERVER] Couldnt find a RX chan\n";
-    reply_data = pmt_list3(invocation_handle, pmt_from_long(CHANNEL_UNAVAIL), PMT_NIL);  // no free RX chan found
-    d_rx[port]->send(s_response_allocate_channel, reply_data);
-    return;
-  }
+  // no free TX chan found
+  port->send(s_response_allocate_channel, 
+             pmt_list3(invocation_handle, 
+                       s_err_channel_unavailable, 
+                       PMT_NIL));
+  return;
 }
 
 // Check the port type and deallocate assigned capacity based on this, ensuring
-// that the owner of the method invocation is the owner of the port and that
-// the channel number is valid.
-void usrp_server::handle_cmd_deallocate_channel(pmt_t port_id, pmt_t data) {
+// that the owner of the method invocation is the owner of the port and that the
+// channel number is valid.
+void 
+usrp_server::handle_cmd_deallocate_channel(
+                              mb_port_sptr port, 
+                              std::vector<struct channel_info> &chan_info, 
+                              pmt_t data)
+{
 
   pmt_t invocation_handle = pmt_nth(0, data); 
   long channel = pmt_to_long(pmt_nth(1, data));
-  long port;
-  pmt_t reply_data;
-  
-  // Check that the channel number is valid, and that the calling port is the owner
-  // of the channel, and if so remove the assigned capacity.
-  if((port = tx_port_index(port_id)) != -1) {
-  
-    if(channel >= d_ntx_chan) {
-      reply_data = pmt_list2(invocation_handle, pmt_from_long(CHANNEL_INVALID));   // not a legit channel number
-      d_tx[port]->send(s_response_deallocate_channel, reply_data);
-      return;
-    }
 
-    if(d_chaninfo_tx[channel].owner != port_id) {
-      reply_data = pmt_list2(invocation_handle, pmt_from_long(PERMISSION_DENIED));   // not the owner of the port
-      d_tx[port]->send(s_response_deallocate_channel, reply_data);
-      return;
-    }
-
-    d_chaninfo_tx[channel].assigned_capacity = 0;
-    d_chaninfo_tx[channel].owner = PMT_NIL;
-
-    reply_data = pmt_list2(invocation_handle, PMT_T);
-    d_tx[port]->send(s_response_deallocate_channel, reply_data);
+  // Ensure the channel is valid and the caller owns the port
+  if(!check_valid(port, channel, chan_info,
+                  pmt_list2(s_response_deallocate_channel, invocation_handle)))
     return;
-  }
-
-  // Repeated process on the RX side
-  if((port = rx_port_index(port_id)) != -1) {
   
-    if(channel >= d_nrx_chan) {
-      reply_data = pmt_list2(invocation_handle, pmt_from_long(CHANNEL_INVALID));   // not a legit channel number
-      d_rx[port]->send(s_response_deallocate_channel, reply_data);
-      return;
-    }
-
-    if(d_chaninfo_rx[channel].owner != port_id) {
-      reply_data = pmt_list2(invocation_handle, pmt_from_long(PERMISSION_DENIED));   // not the owner of the port
-      d_rx[port]->send(s_response_deallocate_channel, reply_data);
-      return;
-    }
-
-    d_chaninfo_rx[channel].assigned_capacity = 0;
-    d_chaninfo_rx[channel].owner = PMT_NIL;
-
-    reply_data = pmt_list2(invocation_handle, PMT_T);
-    d_rx[port]->send(s_response_deallocate_channel, reply_data);
-    return;
-  }
+  chan_info[channel].assigned_capacity = 0;
+  chan_info[channel].owner = PMT_NIL;
 
+  port->send(s_response_deallocate_channel, 
+             pmt_list2(invocation_handle, 
+                       PMT_T));
+  return;
 }
 
-void usrp_server::handle_cmd_xmit_raw_frame(pmt_t data) {
+void usrp_server::handle_cmd_xmit_raw_frame(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data) {
 
   size_t n_bytes, psize;
   long max_payload_len = transport_pkt::max_payload();
@@ -361,10 +596,18 @@ void usrp_server::handle_cmd_xmit_raw_frame(pmt_t data) {
   long channel = pmt_to_long(pmt_nth(1, data));
   const void *samples = pmt_uniform_vector_elements(pmt_nth(2, data), n_bytes);
   long timestamp = pmt_to_long(pmt_nth(3, data));
+  
+  // Ensure the channel is valid and the caller owns the port
+  if(!check_valid(port, channel, chan_info,
+                  pmt_list2(s_response_xmit_raw_frame, invocation_handle)))
+    return;
+  
+  // Determine the number of packets to allocate contiguous memory for
+  // bursting over the USB and get a pointer to the memory to be used in
+  // building the packets
+  long n_packets = 
+    static_cast<long>(std::ceil(n_bytes / (double)max_payload_len));
 
-  // Determine the number of packets to allocate contiguous memory for bursting over the
-  // USB and get a pointer to the memory to be used in building the packets
-  long n_packets = static_cast<long>(std::ceil(n_bytes / (double)max_payload_len));
   pmt_t v_packets = pmt_make_u8vector(sizeof(transport_pkt) * n_packets, 0);
 
   transport_pkt *pkts =
@@ -372,7 +615,8 @@ void usrp_server::handle_cmd_xmit_raw_frame(pmt_t data) {
 
   for(int n=0; n < n_packets; n++) {
 
-    long payload_len = std::min((long)(n_bytes-(n*max_payload_len)), (long)max_payload_len);
+    long payload_len = 
+      std::min((long)(n_bytes-(n*max_payload_len)), (long)max_payload_len);
   
     if(n == 0) { // first packet gets start of burst flag and timestamp
       pkts[n].set_header(pkts[n].FL_START_OF_BURST, channel, 0, payload_len);
@@ -382,14 +626,740 @@ void usrp_server::handle_cmd_xmit_raw_frame(pmt_t data) {
       pkts[n].set_timestamp(0xffffffff);
     }
 
-    memcpy(pkts[n].payload(), (uint8_t *)samples+(max_payload_len * n), payload_len);
+    memcpy(pkts[n].payload(), 
+           (uint8_t *)samples+(max_payload_len * n), 
+           payload_len);
+  
+  }
+
+
+  pkts[n_packets-1].set_end_of_burst(); // set the last packet's end of burst
+
+  if (verbose)
+    std::cout << "[USRP_SERVER] Received raw frame invocation: " 
+              << invocation_handle << std::endl;
+    
+  // The actual response to the write will be generated by a
+  // s_response_usrp_write
+  d_cs_usrp->send(s_cmd_usrp_write, 
+                  pmt_list3(invocation_handle, 
+                            pmt_from_long(channel), 
+                            v_packets));
+
+  return;
+}
+
+void usrp_server::handle_cmd_to_control_channel(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data) 
+{
+
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t subpackets = pmt_nth(1, data);
+
+  long n_subpkts = pmt_length(subpackets);
+  long curr_subpkt = 0;
+
+  size_t psize;
+  long payload_len = 0;
+  long channel = 0x1f;
+
+  // The design of the following code is optimized for simplicity, not
+  // performance.  To performance optimize this code, the total size in bytes
+  // needed for all of the CS packets is needed to allocate contiguous memory
+  // which contains the USB packets for bursting over the bus.  However to do
+  // this the packets subpackets would need to be parsed twice and their sizes
+  // would need to be determined.
+  //
+  // The approach taken is to keep parsing the subpackets and putting them in to
+  // USB packets.  Once the USB packet is full, a write is sent for it and
+  // another packet is created.
+  //
+  // The subpacket creation methods will return false if the subpacket will not
+  // fit in to the current USB packet.  In these cases a new USB packet is
+  // created and the old is sent.
+  
+  new_packet:
+    // This code needs to become "smart" and only make a new packet when full
+    pmt_t v_packet = pmt_make_u8vector(sizeof(transport_pkt), 0);
+    transport_pkt *pkt = (transport_pkt *) pmt_u8vector_writeable_elements(v_packet, psize);
+    payload_len = 0;
+    
+    pkt->set_header(0, channel, 0, payload_len);
+    pkt->set_timestamp(0xffffffff);
+
+  while(curr_subpkt < n_subpkts) {
+
+    pmt_t subp = pmt_nth(curr_subpkt, subpackets);
+    pmt_t subp_cmd = pmt_nth(0, subp);
+    pmt_t subp_data = pmt_nth(1, subp);
+
+    //--------- PING FIXED --------------//
+    if(pmt_eq(subp_cmd, s_op_ping_fixed)) {
+
+      long urid     = pmt_to_long(pmt_nth(0, subp_data));
+      long pingval  = pmt_to_long(pmt_nth(1, subp_data));
+
+      // USRP server sets request ID's to keep track of which application gets
+      // what response back.  To allow a full 6-bits for an RID to the user, we
+      // keep a mapping and replace the RID's as the packets go in and out.  If
+      // there are no RID's available, the command is thrown away silently. 
+      long srid;
+      if((srid = next_rid()) == -1)
+        goto subpkt_bail;
+
+      // We use a vector to store the owner of the ping request and will use it
+      // to send the request on any RX port they own. 
+      d_rids[srid].owner = port->port_symbol();
+      d_rids[srid].user_rid = urid;
+        
+      // Adds a ping after the previous command in the pkt
+      if(!pkt->cs_ping(srid, pingval))
+      {
+        d_cs_usrp->send(s_cmd_usrp_write, 
+                        pmt_list3(invocation_handle, 
+                                  pmt_from_long(channel), 
+                                  v_packet));
+
+        // Return the RID
+        d_rids[srid].owner = PMT_NIL;
+
+        goto new_packet;
+      }
+
+      if(verbose)
+        std::cout << "[USRP_SERVER] Received ping command request"
+                  << " assigning RID " << srid << std::endl;
+
+    }
+  
+    //----------- WRITE REG ---------------//
+    if(pmt_eq(subp_cmd, s_op_write_reg)) {
+      
+      long reg_num = pmt_to_long(pmt_nth(0, subp_data));
+      long val = pmt_to_long(pmt_nth(1, subp_data));
+
+      if(!pkt->cs_write_reg(reg_num, val))
+      {
+        d_cs_usrp->send(s_cmd_usrp_write, 
+                        pmt_list3(invocation_handle, 
+                                  pmt_from_long(channel), 
+                                  v_packet));
+        
+        goto new_packet;
+      }
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Received write register request "
+                  << "("
+                  << "Reg: " << reg_num << ", "
+                  << "Val: " << val
+                  << ")\n";
+    }
+    
+    //------- WRITE REG MASKED ----------//
+    if(pmt_eq(subp_cmd, s_op_write_reg_masked)) {
+      
+      long reg_num = pmt_to_long(pmt_nth(0, subp_data));
+      long val = pmt_to_long(pmt_nth(1, subp_data));
+      long mask = pmt_to_long(pmt_nth(2, subp_data));
+
+      if(!pkt->cs_write_reg_masked(reg_num, val, mask))
+      {
+        d_cs_usrp->send(s_cmd_usrp_write, 
+                        pmt_list3(invocation_handle, 
+                                  pmt_from_long(channel), 
+                                  v_packet));
+        
+        goto new_packet;
+      }
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Received write register masked request\n";
+    }
+    
+    //------------ READ REG --------------//
+    if(pmt_eq(subp_cmd, s_op_read_reg)) {
+      
+      long urid     = pmt_to_long(pmt_nth(0, subp_data));
+      long reg_num  = pmt_to_long(pmt_nth(1, subp_data));
+
+      long srid;
+      if((srid = next_rid()) == -1)
+        goto subpkt_bail;
+
+      d_rids[srid].owner = port->port_symbol();
+      d_rids[srid].user_rid = urid;
+
+      if(!pkt->cs_read_reg(srid, reg_num))
+      {
+        d_cs_usrp->send(s_cmd_usrp_write, 
+                        pmt_list3(invocation_handle, 
+                                  pmt_from_long(channel), 
+                                  v_packet));
+
+        // Return the rid
+        d_rids[srid].owner = PMT_NIL;
+        
+        goto new_packet;
+      }
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Received read register request"
+                  << " assigning RID " << srid << std::endl;
+    }
+    
+    //------------ DELAY --------------//
+    if(pmt_eq(subp_cmd, s_op_delay)) {
+
+      long ticks = pmt_to_long(pmt_nth(0, subp_data));
+
+      if(!pkt->cs_delay(ticks))
+      {
+        d_cs_usrp->send(s_cmd_usrp_write, 
+                        pmt_list3(invocation_handle, 
+                                  pmt_from_long(channel), 
+                                  v_packet));
+        
+        goto new_packet;
+      }
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Received delay request of "
+                  << ticks << " ticks\n";
+    }
+
+    //--------- I2C WRITE -----------//
+    // FIXME: could check that byte count does not exceed 2^8 which
+    // is the max length in the subpacket for # of bytes to read.
+    if(pmt_eq(subp_cmd, s_op_i2c_write)) {
+      
+      long i2c_addr = pmt_to_long(pmt_nth(0, subp_data));
+      pmt_t data = pmt_nth(1, subp_data);
+
+      // Get a readable address to the data which also gives us the length
+      size_t data_len;
+      uint8_t *i2c_data = (uint8_t *) pmt_u8vector_writeable_elements(data, data_len);
+
+      // Make the USB packet
+      if(!pkt->cs_i2c_write(i2c_addr, i2c_data, data_len))
+      {
+        d_cs_usrp->send(s_cmd_usrp_write, 
+                        pmt_list3(invocation_handle, 
+                                  pmt_from_long(channel), 
+                                  v_packet));
+        
+        goto new_packet;
+      }
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Received I2C write\n";
+    }
+  
+    //----------- I2C Read -------------//
+    if(pmt_eq(subp_cmd, s_op_i2c_read)) {
+      
+      long urid       = pmt_to_long(pmt_nth(0, subp_data));
+      long i2c_addr   = pmt_to_long(pmt_nth(1, subp_data));
+      long i2c_bytes  = pmt_to_long(pmt_nth(2, subp_data));
+
+      long srid;
+      if((srid = next_rid()) == -1)
+        goto subpkt_bail;
+      
+      d_rids[srid].owner = port->port_symbol();
+      d_rids[srid].user_rid = urid;
+
+      if(!pkt->cs_i2c_read(srid, i2c_addr, i2c_bytes))
+      {
+        
+        d_cs_usrp->send(s_cmd_usrp_write, 
+                        pmt_list3(invocation_handle, 
+                                  pmt_from_long(channel), 
+                                  v_packet));
+
+        d_rids[srid].owner = PMT_NIL;
+
+        goto new_packet;
+      }
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Received I2C read\n";
+    }
+    
+    //--------- SPI WRITE -----------//
+    if(pmt_eq(subp_cmd, s_op_spi_write)) {
+      
+      long enables = pmt_to_long(pmt_nth(0, subp_data));
+      long format = pmt_to_long(pmt_nth(1, subp_data));
+      long opt = pmt_to_long(pmt_nth(2, subp_data));
+      pmt_t data = pmt_nth(3, subp_data);
+
+      // Get a readable address to the data which also gives us the length
+      size_t data_len;
+      uint8_t *spi_data = (uint8_t *) pmt_u8vector_writeable_elements(data, data_len);
+
+      // Make the USB packet
+      if(!pkt->cs_spi_write(enables, format, opt, spi_data, data_len))
+      {
+        d_cs_usrp->send(s_cmd_usrp_write, 
+                        pmt_list3(invocation_handle, 
+                                  pmt_from_long(channel), 
+                                  v_packet));
+        
+        goto new_packet;
+      }
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Received SPI write\n";
+    }
+    
+    //--------- SPI READ -----------//
+    if(pmt_eq(subp_cmd, s_op_spi_read)) {
+      
+      long urid     = pmt_to_long(pmt_nth(0, subp_data));
+      long enables  = pmt_to_long(pmt_nth(1, subp_data));
+      long format   = pmt_to_long(pmt_nth(2, subp_data));
+      long opt      = pmt_to_long(pmt_nth(3, subp_data));
+      long n_bytes  = pmt_to_long(pmt_nth(4, subp_data));
+      
+      long srid;
+      if((srid = next_rid()) == -1)
+        goto subpkt_bail;
+
+      d_rids[srid].owner = port->port_symbol();
+      d_rids[srid].user_rid = urid;
+
+      // Make the USB packet
+      if(!pkt->cs_spi_read(srid, enables, format, opt, n_bytes))
+      {
+        d_cs_usrp->send(s_cmd_usrp_write, 
+                        pmt_list3(invocation_handle, 
+                                  pmt_from_long(channel), 
+                                  v_packet));
+        
+        // Return the rid
+        d_rids[srid].owner = PMT_NIL;
+
+        goto new_packet;
+      }
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Received SPI read\n";
+    }
+
+  subpkt_bail:
+    curr_subpkt++;
+
+  }
+
+
+  // If the current packets length is > 0, we know there are subpackets that
+  // need to be sent out still.
+  if(pkt->payload_len() > 0)
+    d_cs_usrp->send(s_cmd_usrp_write, 
+                    pmt_list3(invocation_handle, 
+                              pmt_from_long(channel), 
+                              v_packet));
+
+  return;
+}
+
+void
+usrp_server::handle_cmd_start_recv_raw_samples(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  long channel = pmt_to_long(pmt_nth(1, data));
+
+  // Ensure the channel is valid and the caller owns the port
+  if(!check_valid(port, channel, chan_info,
+                  pmt_list2(s_response_xmit_raw_frame, invocation_handle)))
+    return;
+
+  // Already started receiving samples? (another start before a stop)
+  // Check the RX channel bitmask.
+  if(d_rx_chan_mask & (1 << channel)) {
+    port->send(s_response_recv_raw_samples,
+               pmt_list5(invocation_handle,
+                         s_err_already_receiving,
+                         PMT_NIL,
+                         PMT_NIL,
+                         PMT_NIL));
+    return;
+  }
+
+  // We only need to generate a 'start reading' command down to the
+  // low level interface if no other channel is already reading
+  //
+  // We carry this over the CS interface because the lower level
+  // interface does not care about the channel, we only demux it
+  // at the usrp_server on responses.
+  if(d_rx_chan_mask == 0) {
+    
+    if(verbose)
+      std::cout << "[USRP_SERVER] Sending read request down to start recv\n";
+
+    d_cs_usrp->send(s_cmd_usrp_start_reading, pmt_list1(invocation_handle));
+  }
+
+  d_rx_chan_mask |= 1<<channel;
+  
+  return;
+}
+
+void
+usrp_server::handle_cmd_stop_recv_raw_samples(
+                        mb_port_sptr port, 
+                        std::vector<struct channel_info> &chan_info, 
+                        pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  long channel = pmt_to_long(pmt_nth(1, data));
+
+  // FIX ME : we have no responses to send an error...
+  // Ensure the channel is valid and the caller owns the port
+  //if(!check_valid(port, channel, chan_info,
+  //                pmt_list2(s_response_xmit_raw_frame, invocation_handle)))
+  //  return;
+
+  // Remove this hosts bit from the receiver mask
+  d_rx_chan_mask &= ~(1<<channel);
+
+  // We only need to generate a 'start reading' command down to the
+  // low level interface if no other channel is already reading
+  //
+  // We carry this over the CS interface because the lower level
+  // interface does not care about the channel, we only demux it
+  // at the usrp_server on responses.
+  if(d_rx_chan_mask == 0) {
+    
+    if(verbose)
+      std::cout << "[USRP_SERVER] Sending stop reading request down\n";
+
+    d_cs_usrp->send(s_cmd_usrp_stop_reading, pmt_list1(invocation_handle));
+  }
+  
+  return;
+}
+
+// Read the packet header, determine the port by the channel owner
+void
+usrp_server::handle_response_usrp_read(pmt_t data)
+{
+
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+  pmt_t v_pkt = pmt_nth(2, data);
+
+  size_t n_bytes;
+  size_t ignore;
+
+  if (d_fake_rx) {
+
+    pmt_t pkt = pmt_nth(2, data);
+
+    d_rx[0]->send(s_response_recv_raw_samples,
+                  pmt_list5(PMT_F,
+                            PMT_T,
+                            pkt,
+                            pmt_from_long(0xffff),
+                            PMT_NIL));
+
+    return;
+  }
+
+  // Extract the packet and return appropriately
+  transport_pkt *pkt = (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, n_bytes);
+
+  // The channel is used to find the port to pass the samples on
+  long channel = pkt->chan();
+  long payload_len = pkt->payload_len();
+  long port;
+
+  // Ignore packets which seem to have incorrect size or size 0
+  if(payload_len > pkt->max_payload() || payload_len == 0)
+    return;
+  
+  // If the packet is a C/S packet, parse it separately
+  if(channel == 0x1f) {
+    parse_control_pkt(invocation_handle, pkt);
+    return;
+  }
+
+  if((port = rx_port_index(d_chaninfo_rx[channel].owner)) == -1)
+    return; // Don't know where to send the sample... possibility on abrupt close
+    
+  pmt_t v_samples = pmt_make_u8vector(payload_len, 0);
+  uint8_t *samples = pmt_u8vector_writeable_elements(v_samples, ignore);
+  
+  memcpy(samples, pkt->payload(), payload_len);
+
+  // Build a properties dictionary to store things such as the RSSI
+  pmt_t properties =  pmt_make_dict();
+
+  pmt_dict_set(properties,
+               pmt_intern("rssi"),
+               pmt_from_long(pkt->rssi()));
+
+  if(pkt->overrun())
+    pmt_dict_set(properties,
+                 pmt_intern("overrun"),
+                 PMT_T);
+
+  if(pkt->underrun())
+    pmt_dict_set(properties,
+                 pmt_intern("underrun"),
+                 PMT_T);
+
+  d_rx[port]->send(s_response_recv_raw_samples,
+                   pmt_list5(invocation_handle,
+                             status,
+                             v_samples,
+                             pmt_from_long(pkt->timestamp()),
+                             properties));
+  return;
+}
+
+void
+usrp_server::parse_control_pkt(pmt_t invocation_handle, transport_pkt *pkt)
+{
+
+  long payload_len = pkt->payload_len();
+  long curr_payload = 0;
+  long port;
+  
+  // We dispatch based on the control packet type, however we can extract the
+  // opcode and the length immediately which is consistent in all responses.
+  //
+  // Since each control packet can have multiple responses, we keep reading the
+  // lengths of each subpacket until we reach the payload length.  
+  while(curr_payload < payload_len) {
+
+    pmt_t sub_packet = pkt->read_subpacket(curr_payload);
+    pmt_t op_symbol = pmt_nth(0, sub_packet);
+
+    int len = pkt->cs_len(curr_payload);
+
+    if(verbose)
+      std::cout << "[USRP_SERVER] Parsing subpacket " 
+                << op_symbol << " ... length " << len << std::endl;
+
+    //----------------- PING RESPONSE ------------------//
+    if(pmt_eq(op_symbol, s_op_ping_fixed_reply)) {
+
+      long srid     = pmt_to_long(pmt_nth(1, sub_packet));
+      pmt_t pingval = pmt_nth(2, sub_packet);
+
+      long urid = d_rids[srid].user_rid;
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Found ping response "
+                  << "("
+                  << "URID: " << urid << ", "
+                  << "SRID: " << srid << ", "
+                  << "VAL: " << pingval 
+                  << ")\n";
+      
+      // Do some bounds checking incase of bogus/corrupt responses
+      if(srid > D_MAX_RID)
+        return;
+
+      pmt_t owner = d_rids[srid].owner;
+
+      // FIXME: should be 1 response for all subpackets here ?
+      if((port = tx_port_index(owner)) != -1)
+        d_tx[port]->send(s_response_from_control_channel,
+                         pmt_list4(invocation_handle,
+                                   PMT_T,
+                                   pmt_list2(s_op_ping_fixed_reply, // subp
+                                             pmt_list2(pmt_from_long(urid), 
+                                                       pingval)),
+                                   pmt_from_long(pkt->timestamp())));
+    }
+    
+    //----------------- READ REG RESPONSE ------------------//
+    else if(pmt_eq(op_symbol, s_op_read_reg_reply)) {
+
+      long srid     = pmt_to_long(pmt_nth(1, sub_packet));
+      pmt_t reg_num = pmt_nth(2, sub_packet);
+      pmt_t reg_val = pmt_nth(3, sub_packet);
+
+      long urid = d_rids[srid].user_rid;
+      
+      if(verbose)
+        std::cout << "[USRP_SERVER] Found read register response "
+                  << "("
+                  << "URID: " << urid << ", "
+                  << "SRID: " << srid << ", "
+                  << "REG: " << reg_num << ", "
+                  << "VAL: " << reg_val 
+                  << ")\n";
+
+      // Do some bounds checking to avoid seg faults
+      if(srid > D_MAX_RID)
+        return;
+      
+      pmt_t owner = d_rids[srid].owner;
+
+      // FIXME: should be 1 response for all subpackets here ?
+      if((port = tx_port_index(owner)) != -1)
+        d_tx[port]->send(s_response_from_control_channel,
+                         pmt_list4(invocation_handle,
+                                   PMT_T,
+                                   pmt_list2(s_op_read_reg_reply, // subp
+                                             pmt_list3(pmt_from_long(urid), 
+                                                       reg_num, 
+                                                       reg_val)),
+                                   pmt_from_long(pkt->timestamp())));
+    }
+
+    //------------------ I2C READ REPLY -------------------//
+    else if(pmt_eq(op_symbol, s_op_i2c_read_reply)) {
+
+      long srid       = pmt_to_long(pmt_nth(1, sub_packet));
+      pmt_t i2c_addr  = pmt_nth(2, sub_packet);
+      pmt_t i2c_data  = pmt_nth(3, sub_packet);
+
+      long urid = d_rids[srid].user_rid;
+
+      if(verbose)
+        std::cout << "[USRP_SERVER] Found i2c read reply "
+                  << "("
+                  << "URID: " << urid << ", "
+                  << "SRID: " << srid << ", "
+                  << "Addr: " << i2c_addr << ", "
+                  << "Data: " << i2c_data
+                  << ")\n";
+      
+      // Do some bounds checking to avoid seg faults
+      if(srid > D_MAX_RID)
+        return;
+
+      pmt_t owner = d_rids[srid].owner;
+
+      if((port = tx_port_index(owner)) != -1)
+        d_tx[port]->send(s_response_from_control_channel,
+                         pmt_list4(invocation_handle,
+                                   PMT_T,
+                                   pmt_list2(s_op_i2c_read_reply,
+                                             pmt_list3(pmt_from_long(urid), 
+                                                       i2c_addr,
+                                                       i2c_data)),
+                                   pmt_from_long(pkt->timestamp())));
+    }
+
+    //------------------ SPI READ REPLY -------------------//
+    else if(pmt_eq(op_symbol, s_op_spi_read_reply)) {
+      
+      long srid       = pmt_to_long(pmt_nth(1, sub_packet));
+      pmt_t spi_data  = pmt_nth(2, sub_packet);
+      
+      long urid = d_rids[srid].user_rid;
+
+      if(verbose)
+        std::cout << "[USRP_SERVER] Found SPI read reply "
+                  << "("
+                  << "URID: " << urid << ", "
+                  << "SRID: " << srid << ", "
+                  << "Data: " << spi_data
+                  << ")\n";
+
+      // Bounds check the RID
+      if(srid > D_MAX_RID)
+        return;
+
+      pmt_t owner = d_rids[srid].owner;
+
+      if((port = tx_port_index(owner)) != -1)
+        d_tx[port]->send(s_response_from_control_channel,
+                         pmt_list4(invocation_handle,
+                                   PMT_T,
+                                   pmt_list2(s_op_spi_read_reply,
+                                             pmt_list2(pmt_from_long(urid), 
+                                                       spi_data)),
+                                   pmt_from_long(pkt->timestamp())));
+    }
+
+    // Each subpacket has an unaccounted for 2 bytes which is the opcode
+    // and the length field
+    curr_payload += len + 2;
+    
+    // All subpackets are 32-bit aligned
+    int align_offset = 4 - (curr_payload % 4);
+
+    if(align_offset != 4)
+      curr_payload += align_offset;
+  }
+}
+
+void
+usrp_server::recall_defer_queue()
+{
+
+  std::vector<mb_message_sptr> recall;
+
+  while(!d_defer_queue.empty()) {
+    recall.push_back(d_defer_queue.front());
+    d_defer_queue.pop();
   }
 
-  pkts[n_packets-1].set_end_of_burst();   // set the last packet's end of burst
+  // Parse the messages that were queued while waiting for an open response
+  for(int i=0; i < (int)recall.size(); i++) 
+    handle_message(recall[i]);
+
+  return;
+}
+
+bool
+usrp_server::check_valid(mb_port_sptr port,
+                         long channel,
+                         std::vector<struct channel_info> &chan_info,
+                         pmt_t signal_info)
+{
 
-  // interface with the USRP to send the USB packet, since the memory is
-  // contiguous, this should be a serious of memory copies to the bus, each being
-  // USB_PKT_SIZE * MAX_PACKET_BURST bytes worth of data (given a full burst)
+  pmt_t response_signal = pmt_nth(0, signal_info);
+  pmt_t invocation_handle = pmt_nth(1, signal_info);
+
+  // not a valid channel number?
+  if(channel >= (long)chan_info.size() && channel != 0x1f) {
+    port->send(response_signal, 
+               pmt_list2(invocation_handle, 
+                         s_err_channel_invalid));
+
+    if(verbose)
+      std::cout << "[USRP_SERVER] Invalid channel number for event " 
+                << response_signal << std::endl;
+    return false;
+  }
+  
+  // not the owner of the port?
+  if(chan_info[channel].owner != port->port_symbol()) {
+    port->send(response_signal, 
+               pmt_list2(invocation_handle, 
+                         s_err_channel_permission_denied));
+    
+    if(verbose)
+      std::cout << "[USRP_SERVER] Invalid permissions"
+                << " for " << response_signal
+                << " from " << port->port_symbol()
+                << " proper owner is " << chan_info[channel].owner
+                << " on channel " << channel
+                << " invocation " << invocation_handle
+                << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+// Goes through the vector of RIDs and retreieves an
+// available one for use
+long
+usrp_server::next_rid()
+{
+  for(int i = 0; i < D_MAX_RID; i++)
+    if(pmt_eqv(d_rids[i].owner, PMT_NIL))
+      return i;
+
+  return -1;
 }
 
 REGISTER_MBLOCK_CLASS(usrp_server);
diff --git a/usrp/host/lib/inband/usrp_server.h b/usrp/host/lib/inband/usrp_server.h
index d2819cd66..81dceb1f4 100644
--- a/usrp/host/lib/inband/usrp_server.h
+++ b/usrp/host/lib/inband/usrp_server.h
@@ -23,21 +23,19 @@
 
 #include <mb_mblock.h>
 #include <vector>
+#include <queue>
+#include <fstream>
+#include <usrp_inband_usb_packet.h>
+
+typedef usrp_inband_usb_packet transport_pkt;   // makes conversion to gigabit easy
 
 /*!
- * \brief Implements the lowest-level mblock interface to the USRP
+ * \brief Implements the lowest-level mblock usb_interface to the USRP
  */
 class usrp_server : public mb_mblock
 {
 public:
 
-  enum error_codes {
-    RQSTD_CAPACITY_UNAVAIL = 0,
-    CHANNEL_UNAVAIL = 1,
-    CHANNEL_INVALID = 2,
-    PERMISSION_DENIED = 3
-  };
-
   // our ports
   enum port_types {
     RX_PORT = 0,
@@ -46,19 +44,49 @@ public:
   static const int N_PORTS = 4;
   std::vector<mb_port_sptr> d_tx, d_rx;
   mb_port_sptr	d_cs;
+  mb_port_sptr	d_cs_usrp;
 
   static const int D_USB_CAPACITY = 32 * 1024 * 1024;
   static const int D_MAX_CHANNELS = 16;
   long d_ntx_chan;
   long d_nrx_chan;
 
+  // Keep track of the request IDs
+  struct rid_info {
+    pmt_t owner;
+    long user_rid;
+
+    rid_info() {
+      owner = PMT_NIL;
+      user_rid = 0;
+    }
+  };
+
+  static const long D_MAX_RID = 64;
+  std::vector<rid_info> d_rids;
+  
   struct channel_info {
-    long assigned_capacity;  // the capacity currently assignedby the channel
+    long assigned_capacity;   // the capacity currently assignedby the channel
     pmt_t owner;              // port ID of the owner of the channel
+
+    channel_info() {
+      assigned_capacity = 0;
+      owner = PMT_NIL;
+    }
   };
 
-  struct channel_info d_chaninfo_tx[D_MAX_CHANNELS];
-  struct channel_info d_chaninfo_rx[D_MAX_CHANNELS];
+  long d_rx_chan_mask;    // A bitmask representing the channels in the
+                          // receiving state
+
+  std::vector<struct channel_info> d_chaninfo_tx;
+  std::vector<struct channel_info> d_chaninfo_rx;
+
+  std::queue<mb_message_sptr> d_defer_queue;
+
+  bool d_defer;
+  bool d_opened;
+
+  bool d_fake_rx;
 
 public:
   usrp_server(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg);
@@ -71,12 +99,21 @@ protected:
   static int max_capacity() { return D_USB_CAPACITY; }
 
 private:
-  void handle_cmd_allocate_channel(pmt_t port_id, pmt_t data);
-  void handle_cmd_deallocate_channel(pmt_t port_id, pmt_t data);
-  void handle_cmd_xmit_raw_frame(pmt_t data);
+  void handle_cmd_allocate_channel(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data);
+  void handle_cmd_deallocate_channel(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data);
+  void handle_cmd_xmit_raw_frame(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data);
+  void handle_cmd_to_control_channel(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data);
+  void handle_cmd_start_recv_raw_samples(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data);
+  void handle_cmd_stop_recv_raw_samples(mb_port_sptr port, std::vector<struct channel_info> &chan_info, pmt_t data);
   int rx_port_index(pmt_t port_id);
   int tx_port_index(pmt_t port_id);
   long current_capacity_allocation();
+  void recall_defer_queue();
+  void reset_channels();
+  void handle_response_usrp_read(pmt_t data);
+  bool check_valid(mb_port_sptr port, long channel, std::vector<struct channel_info> &chan_info, pmt_t signal_info);
+  void parse_control_pkt(pmt_t invocation_handle, transport_pkt *pkt);
+  long next_rid();
 };
 
 #endif /* INCLUDED_USRP_SERVER_H */
diff --git a/usrp/host/lib/inband/usrp_server.mbh b/usrp/host/lib/inband/usrp_server.mbh
index e96c3f1ac..06ec4b996 100644
--- a/usrp/host/lib/inband/usrp_server.mbh
+++ b/usrp/host/lib/inband/usrp_server.mbh
@@ -40,9 +40,8 @@
 ;; mechanism to match asynchronous responses with the commands that
 ;; generated them.
 ;;
-;; status is either #t, indicating success, or a pair containing
-;; (status-code . message), where status-code is a symbol and message
-;; is a string.
+;; status is either #t, indicating success, or a symbol indicating an error.
+;; All symbol's names shall begin with %error-
 
 
 ;; ----------------------------------------------------------------
@@ -128,7 +127,7 @@
 
   (:incoming
 
-   (response-from-control-channel invocation-handle status list-of-subpackets)
+   (response-from-control-channel invocation-handle status list-of-subpackets timestamp)
 
    )
   )
@@ -248,9 +247,9 @@
   (:incoming
    (response-open invocation-handle status)
    (response-close invocation-handle status)
-   (response-max-capacity invocation-handle capacity)
-   (response-ntx-chan invocation-handle ntx-chan)
-   (response-nrx-chan invocation-handle nrx-chan)
-   (response-current-capacity-allocation invocation-handle capacity)
+   (response-max-capacity invocation-handle status capacity)
+   (response-ntx-chan invocation-handle status ntx-chan)
+   (response-nrx-chan invocation-handle status nrx-chan)
+   (response-current-capacity-allocation invocation-handle status capacity)
    )
   )
diff --git a/usrp/host/lib/inband/usrp_tx.cc b/usrp/host/lib/inband/usrp_tx.cc
new file mode 100644
index 000000000..a7a5e4a89
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_tx.cc
@@ -0,0 +1,138 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <usrp_tx.h>
+#include <iostream>
+#include <usb.h>
+#include <mb_class_registry.h>
+#include <usrp_inband_usb_packet.h>
+#include <fpga_regs_common.h>
+#include <usrp_standard.h>
+#include <stdio.h>
+
+#include <symbols_usrp_tx_cs.h>
+
+typedef usrp_inband_usb_packet transport_pkt;
+
+static const bool verbose = false;
+
+usrp_tx::usrp_tx(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(rt, instance_name, user_arg),
+    d_disk_write(false)
+{
+  d_cs = define_port("cs", "usrp-tx-cs", true, mb_port::EXTERNAL);
+  
+  //d_disk_write=true;
+  
+  if(d_disk_write) {
+    d_ofile.open("tx_data.dat",std::ios::binary|std::ios::out);
+    d_cs_ofile.open("tx_cs.dat",std::ios::binary|std::ios::out);
+  }
+}
+
+usrp_tx::~usrp_tx() 
+{
+  if(d_disk_write) {
+    d_ofile.close();
+    d_cs_ofile.close();
+  }
+}
+
+void 
+usrp_tx::initial_transition()
+{
+  
+}
+
+void
+usrp_tx::handle_message(mb_message_sptr msg)
+{
+  pmt_t event = msg->signal();
+  pmt_t port_id = msg->port_id();
+  pmt_t data = msg->data(); 
+
+  // Theoretically only have 1 message to ever expect, but
+  // want to make sure its at least what we want
+  if(pmt_eq(port_id, d_cs->port_symbol())) {
+    
+    if(pmt_eqv(event, s_cmd_usrp_tx_write))
+      write(data);
+  }
+}
+
+void
+usrp_tx::write(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t channel = pmt_nth(1, data);
+  pmt_t v_packets = pmt_nth(2, data);
+  d_utx = boost::any_cast<usrp_standard_tx *>(pmt_any_ref(pmt_nth(3, data)));
+
+  size_t n_bytes;
+  bool underrun;  // this will need to go, as it is taken care of in the packet headers
+
+  transport_pkt *pkts = (transport_pkt *) pmt_u8vector_writeable_elements(v_packets, n_bytes);
+
+  int ret = d_utx->write (pkts, n_bytes, &underrun);
+  
+  if (0 && underrun)
+    fprintf(stderr, "uU");
+
+  if (ret == (int) n_bytes) {
+    if (verbose)
+      std::cout << "[usrp_server] Write of " << n_bytes << " successful\n";
+    // need to respond with the channel so the USRP server knows who to forward the result of
+    // the write to by looking up the owner of the channel
+    d_cs->send(s_response_usrp_tx_write,
+	       pmt_list3(invocation_handle, PMT_T, channel));
+  }
+  else {
+    if (verbose)
+      std::cout << "[usrp_server] Error writing " << n_bytes << " bytes to USB bus\n";
+    d_cs->send(s_response_usrp_tx_write,
+	       pmt_list3(invocation_handle, PMT_F, channel));
+  }
+    
+  long n_packets = 
+    static_cast<long>(std::ceil(n_bytes / (double)transport_pkt::max_pkt_size()));
+
+  for(int i=0; i < n_packets; i++) {
+    
+    if(d_disk_write) {
+      if(pkts[i].chan() == 0x1f)
+        d_cs_ofile.write((const char *)&pkts[i], transport_pkt::max_pkt_size());
+      else
+        d_ofile.write((const char *)&pkts[i], transport_pkt::max_pkt_size());
+
+      d_cs_ofile.flush();
+      d_ofile.flush();
+    }
+  }
+
+
+  return;
+}
+
+REGISTER_MBLOCK_CLASS(usrp_tx);
diff --git a/usrp/host/lib/inband/usrp_tx.h b/usrp/host/lib/inband/usrp_tx.h
new file mode 100644
index 000000000..546a26afc
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_tx.h
@@ -0,0 +1,53 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_USRP_TX_H
+#define INCLUDED_USRP_TX_H
+
+#include <mb_mblock.h>
+#include <fstream>
+
+class usrp_standard_tx;
+
+/*!
+ * \brief Implements the low level usb interface to the USRP
+ */
+class usrp_tx : public mb_mblock
+{
+  mb_port_sptr		d_cs;
+  usrp_standard_tx     *d_utx;
+  
+  bool d_disk_write;
+  std::ofstream d_ofile;
+  std::ofstream d_cs_ofile;
+  
+ public:
+  usrp_tx(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg);
+  ~usrp_tx();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ private:
+  void write(pmt_t data);
+};
+  
+
+#endif /* INCLUDED_USRP_TX_H */
+
diff --git a/usrp/host/lib/inband/usrp_tx_stub.cc b/usrp/host/lib/inband/usrp_tx_stub.cc
new file mode 100644
index 000000000..7a9876322
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_tx_stub.cc
@@ -0,0 +1,344 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <iostream>
+#include <vector>
+#include <usb.h>
+#include <mb_class_registry.h>
+#include <usrp_tx_stub.h>
+#include <usrp_inband_usb_packet.h>
+#include <fpga_regs_common.h>
+#include "usrp_standard.h"
+#include <stdio.h>
+#include <fstream>
+#include <usrp_rx_stub.h>
+
+#include <symbols_usrp_tx_cs.h>
+
+typedef usrp_inband_usb_packet transport_pkt;
+
+static const bool verbose = false;
+
+usrp_tx_stub::usrp_tx_stub(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(rt, instance_name, user_arg),
+    d_disk_write(false)
+{
+  d_cs = define_port("cs", "usrp-tx-cs", true, mb_port::EXTERNAL);
+  
+  //d_disk_write=true;
+  
+  if(d_disk_write) {
+    d_ofile.open("tx_stub_data.dat",std::ios::binary|std::ios::out);
+    d_cs_ofile.open("tx_stub_cs.dat",std::ios::binary|std::ios::out);
+  }
+}
+
+usrp_tx_stub::~usrp_tx_stub() 
+{
+  if(d_disk_write) {
+    d_ofile.close();
+    d_cs_ofile.close();
+  }
+}
+
+void 
+usrp_tx_stub::initial_transition()
+{
+  
+}
+
+void
+usrp_tx_stub::handle_message(mb_message_sptr msg)
+{
+  pmt_t event = msg->signal();
+  pmt_t port_id = msg->port_id();
+  pmt_t data = msg->data(); 
+
+  // Theoretically only have 1 message to ever expect, but
+  // want to make sure its at least what we want
+  if(pmt_eq(port_id, d_cs->port_symbol())) {
+    
+    if(pmt_eqv(event, s_cmd_usrp_tx_write)) 
+      write(data);
+  }
+}
+
+void
+usrp_tx_stub::write(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t channel = pmt_nth(1, data);
+  pmt_t v_packets = pmt_nth(2, data);
+  d_utx = boost::any_cast<usrp_standard_tx *>(pmt_any_ref(pmt_nth(3, data)));
+
+  size_t n_bytes;
+
+  transport_pkt *pkts = (transport_pkt *) pmt_u8vector_writeable_elements(v_packets, n_bytes);
+  long n_packets = static_cast<long>(std::ceil(n_bytes / (double)transport_pkt::max_pkt_size()));
+  
+  // Parse the packets looking for C/S packets and dump them to a disk if
+  // necessary
+  for(long i=0; i<n_packets; i++) {
+
+    if(d_disk_write) {
+      if(pkts[i].chan() == 0x1f)
+        d_cs_ofile.write((const char *)&pkts[i], transport_pkt::max_pkt_size());
+      else
+        d_ofile.write((const char *)&pkts[i], transport_pkt::max_pkt_size());
+
+      d_cs_ofile.flush();
+      d_ofile.flush();
+    }
+
+    if(pkts[i].chan() == 0x1f)
+      parse_cs(invocation_handle, pkts[i]);
+  }
+
+  d_cs->send(s_response_usrp_tx_write,
+       pmt_list3(invocation_handle, PMT_T, channel));
+
+  return;
+}
+
+void
+usrp_tx_stub::parse_cs(pmt_t invocation_handle, transport_pkt pkt)
+{
+  
+  long payload_len = pkt.payload_len();
+  long curr_payload = 0;
+      
+  size_t ignore;
+
+  // There is the possibility that the responses for a single USB packet full of
+  // CS packets will not fit back in a single USB packet, considering some
+  // responses are greater than their commands (read registers).
+ new_packet:
+  pmt_t v_pkt = pmt_make_u8vector(sizeof(transport_pkt), 0);
+  
+  transport_pkt *q_pkt =
+    (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, ignore);
+      
+  q_pkt->set_header(0, 0x1f, 0, 0);
+  q_pkt->set_timestamp(0xffffffff);
+
+  // We dispatch based on the control packet type, however we can extract the
+  // opcode and the length immediately which is consistent in all responses.
+  //
+  // Since each control packet can have multiple responses, we keep reading the
+  // lengths of each subpacket until we reach the payload length.  
+  while(curr_payload < payload_len) {
+
+    pmt_t sub_packet = pkt.read_subpacket(curr_payload);
+    pmt_t op_symbol = pmt_nth(0, sub_packet);
+
+    int len = pkt.cs_len(curr_payload);
+      
+    if(verbose)
+      std::cout << "[USRP_TX_STUB] Parsing subpacket " 
+                << op_symbol << " ... length " << len << std::endl;
+
+    //----------------- PING FIXED ------------------//
+    if(pmt_eq(op_symbol, s_op_ping_fixed)) {
+
+      long rid = pmt_to_long(pmt_nth(1, sub_packet));
+      long pingval = pmt_to_long(pmt_nth(2, sub_packet));
+
+      // Generate a reply and put it in the queue for the RX stub to read
+      if(!q_pkt->cs_ping_reply(rid, pingval))
+        goto new_packet;
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Generated ping response "
+                  << "("
+                  << "RID: " << rid << ", "
+                  << "VAL: " << pingval 
+                  << ")\n";
+    }
+
+    //----------------- READ REG ------------------//
+    if(pmt_eq(op_symbol, s_op_read_reg)) {
+
+      long rid = pmt_to_long(pmt_nth(1, sub_packet));
+      long reg_num = pmt_to_long(pmt_nth(2, sub_packet));
+      long reg_val = 0xdeef;
+
+      // Generate a reply and put it in the queue for the RX stub to read
+      if(!q_pkt->cs_read_reg_reply(rid, reg_num, reg_val))
+        goto new_packet;
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Generated read register response "
+                  << "("
+                  << "RID: " << rid << ", "
+                  << "REG: " << reg_num << ", "
+                  << "VAL: " << reg_val
+                  << ")\n";
+    }
+    
+    //----------------- DELAY ------------------//
+    if(pmt_eq(op_symbol, s_op_delay)) {
+
+      long ticks = pmt_to_long(pmt_nth(1, sub_packet));
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Received delay command "
+                  << "("
+                  << "Ticks: " << ticks
+                  << ")\n";
+    }
+
+    //----------------- WRITE REG ------------------//
+    if(pmt_eq(op_symbol, s_op_write_reg)) {
+
+      pmt_t reg_num = pmt_nth(1, sub_packet);
+      pmt_t reg_val = pmt_nth(2, sub_packet);
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Received write register command "
+                  << "("
+                  << "RegNum: " << reg_num << ", "
+                  << "Val: " << reg_val
+                  << ")\n";
+    }
+    
+    //----------------- WRITE REG MASK ---------------//
+    if(pmt_eq(op_symbol, s_op_write_reg_masked)) {
+
+      pmt_t reg_num = pmt_nth(1, sub_packet);
+      pmt_t reg_val = pmt_nth(2, sub_packet);
+      pmt_t mask    = pmt_nth(3, sub_packet);
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Received write register command "
+                  << "("
+                  << "RegNum: " << reg_num << ", "
+                  << "Val: " << reg_val << ", "
+                  << "Mask: " << mask
+                  << ")\n";
+    }
+
+    //---------------- I2C WRITE ------------------//
+    if(pmt_eq(op_symbol, s_op_i2c_write)) {
+      pmt_t i2c_addr  = pmt_nth(1, sub_packet);
+      pmt_t i2c_data  = pmt_nth(2, sub_packet);
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Received i2c write command "
+                  << "("
+                  << "Addr: " << i2c_addr << ", "
+                  << "Data: " << i2c_data
+                  << ")\n";
+    }
+
+    //---------------- I2C READ ------------------//
+    if(pmt_eq(op_symbol, s_op_i2c_read)) {
+      long rid       = pmt_to_long(pmt_nth(1, sub_packet));
+      long i2c_addr  = pmt_to_long(pmt_nth(2, sub_packet));
+      long i2c_bytes = pmt_to_long(pmt_nth(3, sub_packet));
+
+      // Create data to place as a response, filled with 0xff
+      size_t ignore;
+      pmt_t i2c_data = pmt_make_u8vector(i2c_bytes, 0xff);
+      uint8_t *w_data = (uint8_t *) pmt_u8vector_writeable_elements(i2c_data, ignore);
+
+      // Generate a reply and put it in the queue for the RX stub to read
+      if(!q_pkt->cs_i2c_read_reply(rid, i2c_addr, w_data, i2c_bytes))
+        goto new_packet;
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Received i2c read "
+                  << "("
+                  << "RID: " << rid << ", "
+                  << "Addr: " << i2c_addr << ", "
+                  << "Bytes: " << i2c_bytes
+                  << ")\n";
+    }
+    
+    //---------------- SPI WRITE ------------------//
+    if(pmt_eq(op_symbol, s_op_spi_write)) {
+      long enables  = pmt_to_long(pmt_nth(1, sub_packet));
+      long format   = pmt_to_long(pmt_nth(2, sub_packet));
+      long opt      = pmt_to_long(pmt_nth(3, sub_packet));
+      pmt_t data    = pmt_nth(4, sub_packet);
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Received spi write command "
+                  << "("
+                  << "Enables: " << enables << ", "
+                  << "Format: " << format << ", "
+                  << "Options: " << opt << ", "
+                  << "Data: " << data
+                  << ")\n";
+    }
+
+    //---------------- SPI READ ------------------//
+    if(pmt_eq(op_symbol, s_op_spi_read)) {
+      long rid      = pmt_to_long(pmt_nth(1, sub_packet));
+      long enables  = pmt_to_long(pmt_nth(2, sub_packet));
+      long format   = pmt_to_long(pmt_nth(3, sub_packet));
+      long opt      = pmt_to_long(pmt_nth(4, sub_packet));
+      long n_bytes  = pmt_to_long(pmt_nth(5, sub_packet));
+
+      // Create data to place as a fake response
+      size_t ignore;
+      pmt_t spi_data = pmt_make_u8vector(n_bytes, 0xff);
+      uint8_t *w_data = (uint8_t *) pmt_u8vector_writeable_elements(spi_data, ignore);
+
+      // Generate a reply and put it in the queue for the RX stub to read
+      if(!q_pkt->cs_spi_read_reply(rid, w_data, n_bytes))
+        goto new_packet;
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Received spi read command "
+                  << "("
+                  << "RID: " << rid << ", "
+                  << "Enables: " << enables << ", "
+                  << "Format: " << format << ", "
+                  << "Options: " << opt << ", "
+                  << "Bytes: " << n_bytes
+                  << ")\n";
+      
+    }
+
+    // Each subpacket has an unaccounted for 2 bytes which is the opcode
+    // and the length field
+    curr_payload += len + 2;
+
+    // All subpackets are 32-bit aligned
+    int align_offset = 4 - (curr_payload % 4);
+
+    if(align_offset != 4)
+      curr_payload += align_offset;
+
+  }
+
+  // If the packet has data in the payload, it needs queued
+  if(q_pkt->payload_len() > 0)
+    d_cs_queue.push(pmt_list2(invocation_handle, v_pkt));
+
+  return;
+}
+
+REGISTER_MBLOCK_CLASS(usrp_tx_stub);
diff --git a/usrp/host/lib/inband/usrp_tx_stub.h b/usrp/host/lib/inband/usrp_tx_stub.h
new file mode 100644
index 000000000..52294beec
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_tx_stub.h
@@ -0,0 +1,61 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_USRP_TX_STUB_H
+#define INCLUDED_USRP_TX_STUB_H
+
+#include <mb_mblock.h>
+#include <vector>
+#include "usrp_standard.h"
+#include <fstream>
+#include <usrp_inband_usb_packet.h>
+
+typedef usrp_inband_usb_packet transport_pkt;
+
+/*!
+ * \brief Implements the low level usb interface to the USRP
+ */
+class usrp_tx_stub : public mb_mblock
+{
+ public:
+
+  mb_port_sptr	d_cs;
+  usrp_standard_tx* d_utx;
+  
+  std::ofstream d_ofile;
+  std::ofstream d_cs_ofile;
+
+  bool d_disk_write;
+
+ public:
+  usrp_tx_stub(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg);
+  ~usrp_tx_stub();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ private:
+  void write(pmt_t data);
+  void parse_cs(pmt_t invocation_handle, transport_pkt pkt);
+ 
+};
+  
+
+#endif /* INCLUDED_USRP_TX_STUB_H */
+
diff --git a/usrp/host/lib/inband/usrp_usb_interface.cc b/usrp/host/lib/inband/usrp_usb_interface.cc
new file mode 100644
index 000000000..b2ccba81b
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_usb_interface.cc
@@ -0,0 +1,431 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <usrp_usb_interface.h>
+
+#include <iostream>
+#include <vector>
+#include <usb.h>
+#include <mb_class_registry.h>
+#include <usrp_inband_usb_packet.h>
+#include <fpga_regs_common.h>
+#include "usrp_rx.h"
+#include <usrp_rx_stub.h>
+#include "usrp_tx.h"
+#include "usrp_standard.h"
+#include <stdio.h>
+
+typedef usrp_inband_usb_packet transport_pkt;
+
+#include <symbols_usrp_interface_cs.h>
+#include <symbols_usrp_tx_cs.h>
+#include <symbols_usrp_rx_cs.h>
+static pmt_t s_shutdown = pmt_intern("%shutdown");
+
+static const bool verbose = false;
+
+
+
+// need to take number of TX and RX channels as parameter
+usrp_usb_interface::usrp_usb_interface(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(rt, instance_name, user_arg),
+  d_fpga_debug(false),
+  d_fake_usrp(false),
+  d_interp_tx(16),
+  d_interp_rx(16),
+  d_rf_freq(10e6),
+  d_rbf("inband_tx_rx.rbf")
+{
+  // Dictionary for arguments to all of the components
+  pmt_t usrp_dict = user_arg;
+  
+  // Default TX/RX interface
+  std::string tx_interface = "usrp_tx";
+  std::string rx_interface = "usrp_rx";
+  
+  if (pmt_is_dict(usrp_dict)) {
+
+    // The 'fake-usrp' key enables the TX and RX stubs if PMT_T
+    if(pmt_t fake_usrp = pmt_dict_ref(usrp_dict, 
+                                      pmt_intern("fake-usrp"), 
+                                      PMT_NIL)) {
+      if(pmt_eqv(fake_usrp, PMT_T)) {
+        tx_interface = "usrp_tx_stub";
+        rx_interface = "usrp_rx_stub";
+        d_fake_usrp=true;
+      }
+    }
+
+    // Read the TX interpolations
+    if(pmt_t interp_tx = pmt_dict_ref(usrp_dict, 
+                                      pmt_intern("interp-tx"), 
+                                      PMT_NIL)) {
+      if(!pmt_eqv(interp_tx, PMT_NIL)) 
+        d_interp_tx = pmt_to_long(interp_tx);
+    }
+    
+    // Read the RX interpolations
+    if(pmt_t interp_rx = pmt_dict_ref(usrp_dict, 
+                                      pmt_intern("interp-rx"), 
+                                      PMT_NIL)) {
+      if(!pmt_eqv(interp_rx, PMT_NIL)) 
+        d_interp_rx = pmt_to_long(interp_rx);
+    }
+
+    // Read the RBF
+    if(pmt_t rbf = pmt_dict_ref(usrp_dict, 
+                                pmt_intern("rbf"), 
+                                PMT_NIL)) {
+      if(!pmt_eqv(rbf, PMT_NIL)) 
+        d_rbf = pmt_symbol_to_string(rbf);
+    }
+
+    // The RF center frequency
+    if(pmt_t rf_freq = pmt_dict_ref(usrp_dict, 
+                                pmt_intern("rf-freq"), 
+                                PMT_NIL)) {
+      if(!pmt_eqv(rf_freq, PMT_NIL)) 
+        d_rf_freq = pmt_to_long(rf_freq);
+    }
+  }
+  
+  if (verbose) {
+    std::cout << "[USRP_USB_INTERFACE] Setting USRP RBF to " 
+              << d_rbf << std::endl;
+    
+    std::cout << "[USRP_USB_INTERFACE] Setting TX interpolation to " 
+              << d_interp_tx << std::endl;
+          
+    std::cout << "[USRP_USB_INTERFACE] Setting RX interpolation to " 
+              << d_interp_rx << std::endl;
+
+    std::cout << "[USRP_USB_INTERFACE] Using TX interface: " 
+              << tx_interface << "\n";
+
+    std::cout << "[USRP_USB_INTERFACE] Using RX interface: " 
+              << rx_interface << "\n";
+
+  }
+
+  d_cs = define_port("cs", "usrp-interface-cs", true, mb_port::EXTERNAL);	
+  d_rx_cs = define_port("rx_cs", "usrp-rx-cs", false, mb_port::INTERNAL);	
+  d_tx_cs = define_port("tx_cs", "usrp-tx-cs", false, mb_port::INTERNAL);	
+
+  // Connect to TX and RX
+  define_component("tx", tx_interface, PMT_F);
+  define_component("rx", rx_interface, PMT_F);
+  connect("self", "rx_cs", "rx", "cs");
+  connect("self", "tx_cs", "tx", "cs");
+  
+  // FIX ME: the code should query the FPGA to retrieve the number of channels and such
+  d_ntx_chan = 2;
+  d_nrx_chan = 2;
+
+  d_utx = NULL;
+  d_urx = NULL;
+  
+  d_fpga_debug=true;   // WARNING: DO NOT ENABLE WITH D'BOARDS OTHER THAN BASIC TX/RX
+
+}
+
+usrp_usb_interface::~usrp_usb_interface() 
+{ 
+
+}
+
+void 
+usrp_usb_interface::initial_transition()
+{
+
+}
+
+void
+usrp_usb_interface::handle_message(mb_message_sptr msg)
+{
+  pmt_t event = msg->signal();		// the "name" of the message
+  pmt_t port_id = msg->port_id();	// which port it came in on
+  pmt_t data = msg->data();
+  pmt_t invocation_handle;
+
+  if (pmt_eq(event, s_shutdown))	// ignore (for now)
+    return;
+
+  //------------- CONTROL / STATUS -------------//
+  if (pmt_eq(port_id, d_cs->port_symbol())) {	
+
+    //------------ OPEN --------------//
+    if (pmt_eq(event, s_cmd_usrp_open)){
+      handle_cmd_open(data);
+      return;
+    }
+    //----------- CLOSE -------------//
+    else if (pmt_eq(event, s_cmd_usrp_close)) {
+      handle_cmd_close(data);
+      return;
+    }
+    //---------- NTX CHAN ----------//
+    else if (pmt_eq(event, s_cmd_usrp_ntx_chan)) {
+      invocation_handle = pmt_nth(0, data);
+      d_cs->send(s_response_usrp_ntx_chan, 
+                 pmt_list2(invocation_handle, 
+                           pmt_from_long(d_ntx_chan)));
+      return;
+    }
+    //---------- NRX CHAN ----------//
+    else if (pmt_eq(event, s_cmd_usrp_nrx_chan)) {
+      invocation_handle = pmt_nth(0, data);
+      d_cs->send(s_response_usrp_nrx_chan, 
+                 pmt_list2(invocation_handle, 
+                           pmt_from_long(d_nrx_chan)));
+      return;
+    }
+    //------------ WRITE -----------//
+    else if(pmt_eq(event, s_cmd_usrp_write)) {
+      handle_cmd_write(data);
+      return;
+    }
+    //-------- START READING --------//
+    else if(pmt_eq(event, s_cmd_usrp_start_reading)) {
+      handle_cmd_start_reading(data);
+      return;
+    }
+    //-------- STOP READING --------//
+    else if(pmt_eq(event, s_cmd_usrp_stop_reading)) {
+      handle_cmd_stop_reading(data);
+      return;
+    }
+
+    goto unhandled;
+  }
+
+  //---------------- RX ------------------//
+  if (pmt_eq(port_id, d_rx_cs->port_symbol())) {	
+
+    // Relay reads back up
+    if(pmt_eq(event, s_response_usrp_rx_read))  {
+      d_cs->send(s_response_usrp_read, data);
+      return;
+    }
+
+    goto unhandled;
+  }
+  
+  //---------------- TX ------------------//
+  if (pmt_eq(port_id, d_tx_cs->port_symbol())) {	
+
+    if(pmt_eq(event, s_response_usrp_tx_write))  {
+
+      pmt_t invocation_handle = pmt_nth(0, data);
+      pmt_t status = pmt_nth(1, data);
+      pmt_t channel = pmt_nth(2, data);
+
+      d_cs->send(s_response_usrp_write,
+                 pmt_list3(invocation_handle,
+                           status,
+                           channel));
+
+      return;
+    }
+
+    goto unhandled;
+  }
+
+ unhandled:
+  std::cout << "[USRP_USB_INTERFACE] unhandled msg: " << msg << std::endl;
+}
+
+void
+usrp_usb_interface::handle_cmd_open(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  long which_usrp = pmt_to_long(pmt_nth(1, data));
+  pmt_t reply_data;
+ 
+  if(d_fake_usrp) {
+    d_cs->send(s_response_usrp_open, pmt_list2(invocation_handle, PMT_T));
+    return;
+  }
+
+  if (verbose)
+    std::cout << "[USRP_USB_INTERFACE] Handling open request for USRP " << which_usrp << "\n";
+
+  // Open up a standard RX and TX for communication with the USRP
+   
+  d_utx = usrp_standard_tx::make(which_usrp,
+				 d_interp_tx,
+				 1,		        // 1 channel
+				 -1,          // mux
+				 4096,        // USB block size
+				 16,          // nblocks for async transfers
+				 d_rbf
+				 );
+  
+  if(d_utx==0) {
+    if (verbose)
+      std::cout << "[USRP_USB_INTERFACE] Failed to open TX\n";
+    reply_data = pmt_list2(invocation_handle, PMT_F);
+    d_cs->send(s_response_usrp_open, reply_data);
+    return;
+  }
+
+  if(!d_utx->set_tx_freq (0,d_rf_freq)) {  // try setting center freq to 0
+    if (verbose)
+      std::cout << "[USRP_USB_INTERFACE] Failed to set center frequency on TX\n";
+    reply_data = pmt_list2(invocation_handle, PMT_F);
+    d_cs->send(s_response_usrp_open, reply_data);
+    return;
+  }
+
+  d_utx->start();
+
+  if (verbose)
+    std::cout << "[USRP_USB_INTERFACE] Setup TX channel\n";
+
+  d_urx =
+    usrp_standard_rx::make (which_usrp,
+			    d_interp_rx,		
+			    1,		        // nchan
+			    -1,           // mux
+			    0,            // set blank mode to start
+			    4096,         // USB block size
+			    16,           // number of blocks for async transfers
+          d_rbf);
+
+  if(!d_urx) {
+    if (verbose)
+      std::cout << "[usrp_server] Failed to open RX\n";
+    reply_data = pmt_list2(invocation_handle, PMT_F);
+    d_cs->send(s_response_usrp_open, reply_data);
+    return;
+  }
+
+  if(!d_urx->set_rx_freq (0, d_rf_freq)) {
+    if (verbose)
+      std::cout << "[usrp_server] Failed to set center frequency on RX\n";
+    reply_data = pmt_list2(invocation_handle, PMT_F);
+    d_cs->send(s_response_usrp_open, reply_data);
+    return;
+  }
+
+  if(d_fpga_debug) {
+    d_utx->_write_fpga_reg(FR_DEBUG_EN,0xf);
+    d_utx->_write_oe(0, 0xffff, 0xffff);
+    d_urx->_write_oe(0, 0xffff, 0xffff);
+    d_utx->_write_oe(1, 0xffff, 0xffff);
+    d_urx->_write_oe(1, 0xffff, 0xffff);
+
+//    while(1){
+//      for(int i=0; i<0xffff; i++) 
+//        d_urx->write_io(0, i, 0xffff);
+//    }
+  }
+  
+  if (verbose)
+    std::cout << "[USRP_USB_INTERFACE] Setup RX channel\n";
+
+  d_cs->send(s_response_usrp_open, pmt_list2(invocation_handle, PMT_T));
+}
+
+void
+usrp_usb_interface::handle_cmd_write(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t channel = pmt_nth(1, data);
+  pmt_t pkts = pmt_nth(2, data);
+
+  pmt_t tx_handle = pmt_make_any(d_utx);
+
+  d_tx_cs->send(s_cmd_usrp_tx_write, 
+                pmt_list4(invocation_handle, 
+                          channel,
+                          pkts,
+                          tx_handle));
+
+  return;
+}
+
+void
+usrp_usb_interface::handle_cmd_start_reading(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  
+  if(verbose)
+    std::cout << "[USRP_USB_INTERFACE] Starting RX...\n";
+
+  if(!d_fake_usrp)
+    d_urx->start();
+
+  pmt_t rx_handle = pmt_make_any(d_urx);
+
+  d_rx_cs->send(s_cmd_usrp_rx_start_reading, pmt_list2(PMT_NIL, rx_handle));
+
+  return;
+}
+
+void
+usrp_usb_interface::handle_cmd_stop_reading(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  
+  if(!d_fake_usrp) {
+    if(verbose)
+      std::cout << "[USRP_USB_INTERFACE] Stopping RX...\n";
+    d_urx->stop();
+  }
+  else {
+    if(verbose)
+      std::cout << "[USRP_USB_INTERFACE] Stopping fake RX...\n";
+    usrp_rx_stop = true;  // extern to communicate with stub to wait
+  }
+
+  return;
+}
+
+void
+usrp_usb_interface::handle_cmd_close(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+
+  if(d_fake_usrp) {
+    d_cs->send(s_response_usrp_close, pmt_list2(invocation_handle, PMT_T));
+    return;
+  }
+  
+  if (verbose)
+    std::cout << "[USRP_USB_INTERFACE] Handling close request for USRP\n";
+
+  delete d_utx;
+  d_utx = 0;
+
+  delete d_urx;
+  d_urx = 0;
+
+  d_cs->send(s_response_usrp_close, pmt_list2(invocation_handle, PMT_T));
+
+  shutdown_all(PMT_T);
+}
+
+
+REGISTER_MBLOCK_CLASS(usrp_usb_interface);
diff --git a/usrp/host/lib/inband/usrp_usb_interface.h b/usrp/host/lib/inband/usrp_usb_interface.h
new file mode 100644
index 000000000..42cda7af1
--- /dev/null
+++ b/usrp/host/lib/inband/usrp_usb_interface.h
@@ -0,0 +1,72 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2007 Free Software Foundation, Inc.
+ * 
+ * This file is part of GNU Radio
+ * 
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef INCLUDED_USRP_USB_INTERFACE_H
+#define INCLUDED_USRP_USB_INTERFACE_H
+
+#include <mb_mblock.h>
+#include <vector>
+#include "usrp_standard.h"
+
+/*!
+ * \brief Implements the low level usb interface to the USRP
+ */
+class usrp_usb_interface : public mb_mblock
+{
+ public:
+
+  usrp_standard_tx* d_utx;
+  usrp_standard_rx* d_urx;
+  
+  mb_port_sptr	d_cs;
+  mb_port_sptr  d_rx_cs;
+  mb_port_sptr  d_tx_cs;
+  
+  long d_ntx_chan;
+  long d_nrx_chan;
+
+  long d_fpga_debug;
+
+  bool d_fake_usrp;
+
+  long d_interp_tx;
+  long d_interp_rx;
+
+  long d_rf_freq;
+
+  std::string d_rbf;
+
+ public:
+  usrp_usb_interface(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg);
+  ~usrp_usb_interface();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ private:
+  void handle_cmd_open(pmt_t data);
+  void handle_cmd_close(pmt_t data);
+  void handle_cmd_write(pmt_t data);
+  void handle_cmd_start_reading(pmt_t data);
+  void handle_cmd_stop_reading(pmt_t data);
+ 
+};
+  
+
+#endif /* INCLUDED_USRP_USB_INTERFACE_H */