25 files changed, 1931 insertions, 304 deletions
diff --git a/usrp/host/apps-inband/Makefile.am b/usrp/host/apps-inband/Makefile.am
index 0faeb7f4be..c05f04af00 100644
--- a/usrp/host/apps-inband/Makefile.am
+++ b/usrp/host/apps-inband/Makefile.am
@@ -35,12 +35,29 @@ noinst_PROGRAMS =			\
 	test_usrp_inband_rx		\
 	test_usrp_inband_tx		\
 	test_usrp_inband_timestamps	\
+	test_usrp_inband_overrun	\
 	test_usrp_inband_underrun	\
+	test_gmac_tx			\
 	read_packets
 
 noinst_HEADERS =			\
 	ui_nco.h			\
-	ui_sincos.h			
+	ui_sincos.h			\
+	gmac.h				\
+	gmac_symbols.h			
+
+
+EXTRA_DIST =				\
+	gmac.mbh
+
+#------------------------------------------------------------------
+# Build gmac sources
+
+BUILT_SOURCES =				\
+	gmac_mbh.cc
+
+gmac_mbh.cc : gmac.mbh
+	$(COMPILE_MBH) $(srcdir)/gmac.mbh gmac_mbh.cc
 
 
 test_usrp_inband_cs_SOURCES 	= test_usrp_inband_cs.cc ui_sincos.c
@@ -58,11 +75,17 @@ test_usrp_inband_timestamps_LDADD   	= $(USRP_LA) $(USRP_INBAND_LA)
 test_usrp_inband_registers_SOURCES 	= test_usrp_inband_registers.cc ui_sincos.c
 test_usrp_inband_registers_LDADD   	= $(USRP_LA) $(USRP_INBAND_LA)
 
+test_usrp_inband_overrun_SOURCES 	= test_usrp_inband_overrun.cc
+test_usrp_inband_overrun_LDADD   	= $(USRP_LA) $(USRP_INBAND_LA)
+
 test_usrp_inband_underrun_SOURCES 	= test_usrp_inband_underrun.cc
 test_usrp_inband_underrun_LDADD   	= $(USRP_LA) $(USRP_INBAND_LA)
 
 test_usrp_inband_rx_SOURCES 	= test_usrp_inband_rx.cc ui_sincos.c
 test_usrp_inband_rx_LDADD   	= $(USRP_LA) $(USRP_INBAND_LA)
 
+test_gmac_tx_SOURCES 	= test_gmac_tx.cc gmac.cc gmac_mbh.cc ui_sincos.c
+test_gmac_tx_LDADD   	= $(USRP_LA) $(USRP_INBAND_LA)
+
 read_packets_SOURCES = read_packets.cc
 read_packets_LDADD = $(USRP_LA) $(USRP_INBAND_LA)
diff --git a/usrp/host/apps-inband/gmac.cc b/usrp/host/apps-inband/gmac.cc
new file mode 100644
index 0000000000..153979162f
--- /dev/null
+++ b/usrp/host/apps-inband/gmac.cc
@@ -0,0 +1,691 @@
+/* -*- 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 <gmac.h>
+
+#include <mb_mblock.h>
+#include <mb_runtime.h>
+#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 <ui_nco.h>
+
+#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>
+
+#include <gmac_symbols.h>
+
+static bool verbose = true;
+
+gmac::gmac(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(rt, instance_name, user_arg),
+    d_us_rx_chan(PMT_NIL), d_us_tx_chan(PMT_NIL)
+{
+
+  // When the MAC layer is initialized, we must connect to the USRP and setup
+  // channels.  We begin by defining ports to connect to the 'usrp_server' block
+  // and then initialize the USRP by opening it through the 'usrp_server.'
+
+  // Initialize the ports
+  define_ports();
+
+  // Initialize the connection to the USRP
+  initialize_usrp();
+
+}
+
+gmac::~gmac()
+{
+}
+
+// The full functionality of GMAC is based on messages passed back and forth
+// between the application and a physical layer and/or usrp_server.  Each
+// message triggers additional events, states, and messages to be sent.
+void gmac::handle_message(mb_message_sptr msg)
+{
+
+  // The MAC functionality is dispatched based on the event, which is the
+  // driving force of the MAC.  The event can be anything from incoming samples
+  // to a message to change the carrier sense threshold.
+  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;
+  pmt_t dict = PMT_NIL;
+  std::string error_msg;
+
+  switch(d_state) {
+    
+    //---------------------------- INIT ------------------------------------//
+    // In the INIT state, there should be no messages across the ports. 
+    case INIT:
+      error_msg = "no messages should be passed during the INIT state:"; 
+      goto unhandled;
+
+    //-------------------------- OPENING USRP -------------------------------//
+    // In this state we expect a response from usrp_server over the CS channel
+    // as to whether or not the opening of the USRP was successful.  If so, we
+    // switch states to allocating the channels for use.
+    case OPENING_USRP:
+
+      if(pmt_eq(event, s_response_open)
+          && pmt_eq(d_us_cs->port_symbol(), port_id)) {
+
+        status = pmt_nth(1, data);          // PMT_T or PMT_F
+
+        if(pmt_eq(status, PMT_T)) {         // on success, allocate channels!
+          allocate_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:
+
+      // ************* TX ALLOCATION RESPONSE ***************** //
+      if(pmt_eq(event, s_response_allocate_channel)
+          && pmt_eq(d_us_tx->port_symbol(), port_id)) 
+      {
+        status = pmt_nth(1, data);
+        
+        if(pmt_eq(status, PMT_T)) {   // extract channel on success
+          d_us_tx_chan = pmt_nth(2, data);
+
+          if(verbose)
+            std::cout << "[GMAC] Received TX allocation"
+                      << " on channel " << d_us_tx_chan << std::endl;
+
+          // If the RX has also been allocated already, we can continue
+          if(!pmt_eqv(d_us_rx_chan, PMT_NIL)) {
+            //enter_receiving();
+            initialize_gmac();
+          }
+
+          return;
+        }
+        else {  // TX allocation failed
+          error_msg = "failed to allocate TX channel:";
+          goto bail;
+        }
+      }
+      
+      // ************* RX ALLOCATION RESPONSE ****************//
+      if(pmt_eq(event, s_response_allocate_channel)
+          && pmt_eq(d_us_rx->port_symbol(), port_id)) 
+      {
+        status = pmt_nth(1, data);
+        
+        if(pmt_eq(status, PMT_T)) {
+          
+          d_us_rx_chan = pmt_nth(2, data);
+
+          if(verbose)
+            std::cout << "[GMAC] Received RX allocation"
+                      << " on channel " << d_us_rx_chan << std::endl;
+
+          // If the TX has also been allocated already, we can continue
+          if(!pmt_eqv(d_us_tx_chan, PMT_NIL)) {
+            //enter_receiving();
+            initialize_gmac();
+          }
+
+          return;
+        }
+        else {  // RX allocation failed
+          error_msg = "failed to allocate RX channel:";
+          goto bail;
+        }
+      }
+
+      goto unhandled;
+    
+    //----------------------------- INIT GMAC --------------------------------//
+    // In the INIT_GMAC state, now that the USRP is initialized we can do things
+    // like right the carrier sense threshold to the FPGA register.
+    case INIT_GMAC:
+      goto unhandled;
+
+    
+    //----------------------------- IDLE ------------------------------------//
+    // In the idle state the MAC is not quite 'idle', it is just not doing
+    // anything specific.  It is still being passive with data between the
+    // application and the lower layer.
+    case IDLE:
+      
+      //-------- TX PORT ----------------------------------------------------//
+      if(pmt_eq(d_tx->port_symbol(), port_id)) {
+
+        //-------- INCOMING PACKET ------------------------------------------//
+        if(pmt_eq(event, s_cmd_tx_pkt)) {
+          handle_cmd_tx_pkt(data);
+          return;
+        }
+
+      }
+
+      //--------- USRP TX PORT ----------------------------------------------//
+      if(pmt_eq(d_us_tx->port_symbol(), port_id)) {
+
+        //-------- INCOMING PACKET RESPONSE ---------------------------------//
+        if(pmt_eq(event, s_response_xmit_raw_frame)) {
+          handle_response_xmit_raw_frame(data);
+          return;
+        }
+
+      }
+
+      //--------- CS PORT ---------------------------------------------------//
+      if(pmt_eq(d_cs->port_symbol(), port_id)) {
+        
+        //------- ENABLE CARRIER SENSE --------------------------------------//
+        if(pmt_eq(event, s_cmd_carrier_sense_enable)) {
+          handle_cmd_carrier_sense_enable(data);
+          return;
+        }
+        
+        //------- CARRIER SENSE THRESHOLD -----------------------------------//
+        if(pmt_eq(event, s_cmd_carrier_sense_threshold)) {
+          handle_cmd_carrier_sense_threshold(data);
+          return;
+        }
+
+        //------- CARRIER SENSE DEADLINE ------------------------------------//
+        if(pmt_eq(event, s_cmd_carrier_sense_deadline)) {
+          handle_cmd_carrier_sense_deadline(data);
+          return;
+        }
+
+        //------- DISABLE CARRIER SENSE -------------------------------------//
+        if(pmt_eq(event, s_cmd_carrier_sense_disable)) {
+          handle_cmd_carrier_sense_disable(data);
+          return;
+        }
+
+      }
+
+      goto unhandled;
+
+    //------------------------ CLOSING CHANNELS -----------------------------//
+    case CLOSING_CHANNELS:
+
+      if (pmt_eq(event, s_response_deallocate_channel)
+          && pmt_eq(d_us_tx->port_symbol(), port_id))
+      {
+        status = pmt_nth(1, data);
+
+        if(pmt_eq(status, PMT_T)) {
+          d_us_tx_chan = PMT_NIL;
+
+          if(verbose)
+            std::cout << "[GMAC] Received TX deallocation\n";
+
+          // If the RX is also deallocated, we can close the USRP
+          if(pmt_eq(d_us_rx_chan, PMT_NIL)) 
+            close_usrp();
+
+          return;
+
+        } else {
+
+          error_msg = "failed to deallocate TX channel:";
+          goto bail;
+
+        }
+      }
+
+      if (pmt_eq(event, s_response_deallocate_channel)
+          && pmt_eq(d_us_rx->port_symbol(), port_id))
+      {
+        status = pmt_nth(1, data);
+
+        // If successful, set the port to NIL
+        if(pmt_eq(status, PMT_T)) {
+          d_us_rx_chan = PMT_NIL;
+
+          if(verbose)
+            std::cout << "[GMAC] Received RX deallocation\n";
+
+          // If the TX is also deallocated, we can close the USRP
+          if(pmt_eq(d_us_tx_chan, PMT_NIL)) 
+            close_usrp();
+
+          return;
+
+        } else {
+          
+          error_msg = "failed to deallocate RX channel:";
+          goto bail;
+
+        }
+      }
+
+      goto unhandled;
+
+    //-------------------------- CLOSING USRP -------------------------------//
+    case CLOSING_USRP:
+      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(0 && verbose && !pmt_eq(event, pmt_intern("%shutdown")))
+    std::cout << "[GMAC] unhandled msg: " << msg
+              << "in state "<< d_state << std::endl;
+}
+
+// The MAC layer connects to 'usrp_server' which has a control/status channel,
+// a TX, and an RX port.  The MAC layer can then relay TX/RX data back and
+// forth to the application, or a physical layer once available.
+void gmac::define_ports()
+{
+  // Ports we use to connect to usrp_server
+  d_us_tx = define_port("us-tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_us_rx = define_port("us-rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_us_cs = define_port("us-cs", "usrp-server-cs", false, mb_port::INTERNAL);
+  
+  // Ports applications used to connect to us
+  d_tx = define_port("tx0", "gmac-tx", true, mb_port::EXTERNAL);
+  d_rx = define_port("rx0", "gmac-rx", true, mb_port::EXTERNAL);
+  d_cs = define_port("cs", "gmac-cs", true, mb_port::EXTERNAL);
+}
+
+// To initialize the USRP we must pass several parameters to 'usrp_server' such
+// as the RBF to use, and the interpolation/decimation rate.  The MAC layer will
+// then pass these parameters to the block with a message to establish the
+// connection to the USRP.
+void gmac::initialize_usrp()
+{
+
+  if(verbose)
+    std::cout << "[GMAC] Initializing USRP\n";
+
+  // The initialization parameters are passed to usrp_server via a PMT
+  // dictionary.
+  pmt_t usrp_dict = pmt_make_dict();
+
+  // Specify the RBF to use
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rbf"),
+               pmt_intern("test2.rbf"));
+
+  pmt_dict_set(usrp_dict,
+               pmt_intern("interp-tx"),
+               pmt_from_long(128));
+
+  pmt_dict_set(usrp_dict,
+               pmt_intern("decim-rx"),
+               pmt_from_long(16));
+  
+  // Center frequency
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rf-freq"),
+               pmt_from_long((long)10e6));
+
+  // Default is to use USRP considered '0' (incase of multiple)
+  d_which_usrp = pmt_from_long(0);
+  
+  define_component("USRP-SERVER", "usrp_server", usrp_dict);
+  
+  connect("self", "us-tx0", "USRP-SERVER", "tx0");
+  connect("self", "us-rx0", "USRP-SERVER", "rx0");
+  connect("self", "us-cs", "USRP-SERVER", "cs");
+
+  // Finally, enter the OPENING_USRP state by sending a request to open the
+  // USRP.
+  open_usrp();
+
+}
+
+// In the initialization state of the MAC layer we set default values for
+// several functionalities.
+void gmac::initialize_gmac()
+{
+
+  // The initial state is the INIT state.
+  d_state = INIT_GMAC;
+
+  // Set carrier sense to enabled by default with the specified threshold and
+  // the deadline to 0 -- which is wait forever.
+  set_carrier_sense(true, 25, 0, PMT_NIL);
+
+  // Can now notify the application that we are initialized
+  d_cs->send(s_response_gmac_initialized,
+             pmt_list2(PMT_NIL, PMT_T));
+
+  // The MAC enters an IDLE state where it waits for messages and dispatches
+  // based on them
+  enter_idle();
+}
+
+// Method for setting the carrier sense and an associated threshold which is
+// written to a register on the FPGA, which it will read if the CS flag is set
+// and perform carrier sense based on.
+//
+// We currently do not wait for the successful response for the write to
+// register command, we assume it will succeed else the MAC must
+void gmac::set_carrier_sense(bool toggle, long threshold, long deadline, pmt_t invocation)
+{
+  d_carrier_sense = toggle;
+
+  // Only waste the bandwidth and processing of a C/S packet if needed
+  if(threshold != d_cs_thresh) {
+    d_us_tx->send(s_cmd_to_control_channel,    // C/S packet
+               pmt_list2(invocation,           // invoc handle
+                         pmt_list1(
+                              pmt_list2(s_op_write_reg, 
+                                        pmt_list2(
+                                        pmt_from_long(REG_CS_THRESH), 
+                                        pmt_from_long(threshold))))));
+    d_cs_thresh = threshold;
+
+    if(verbose)
+      std::cout << "[GMAC] Changing CS threshold: " << d_cs_thresh << std::endl;
+  }
+
+  if(deadline != d_cs_deadline) {
+    d_us_tx->send(s_cmd_to_control_channel,    // C/S packet
+               pmt_list2(invocation,           // invoc handle
+                         pmt_list1(
+                              pmt_list2(s_op_write_reg, 
+                                        pmt_list2(
+                                        pmt_from_long(REG_CS_DEADLINE), 
+                                        pmt_from_long(deadline))))));
+    d_cs_deadline = deadline;
+
+    if(verbose)
+      std::cout << "[GMAC] Changing CS deadline: " << d_cs_deadline << std::endl;
+  }
+
+  if(verbose)
+    std::cout << "[GMAC] Setting carrier sense to " << toggle << std::endl;
+}
+
+// The following sends a command to open the USRP, which will upload the
+// specified RBF when creating the instance of the USRP server and set all other
+// relevant parameters.
+void gmac::open_usrp()
+{
+  d_state = OPENING_USRP;
+
+  d_us_cs->send(s_cmd_open, pmt_list2(PMT_NIL, d_which_usrp));
+  
+  if(verbose)
+    std::cout << "[GMAC] Opening USRP " 
+              << d_which_usrp << std::endl;
+}
+
+// Before sending the close to the USRP we wait a couple seconds to let any data
+// through the USB exit, else a bug in the driver will kick an error and cause
+// an abnormal termination.
+void gmac::close_usrp()
+{
+  d_state = CLOSING_USRP;
+
+  sleep(2);
+
+  d_us_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
+}
+
+// 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 gmac::allocate_channels()
+{
+  d_state = ALLOCATING_CHANNELS;
+  
+  if(verbose)
+    std::cout << "[GMAC] Sending channel allocation requests\n";
+
+  long capacity = (long) 16e6;
+  d_us_tx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+  d_us_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
+
+}
+
+// Before closing the USRP connection, we deallocate our channels so that the
+// capacity can be reused.
+void gmac::close_channels()
+{
+  d_state = CLOSING_CHANNELS;
+
+  d_us_tx->send(s_cmd_deallocate_channel, pmt_list2(PMT_NIL, d_us_tx_chan));
+  d_us_rx->send(s_cmd_deallocate_channel, pmt_list2(PMT_NIL, d_us_rx_chan));
+
+  if(verbose)
+    std::cout << "[GMAC] Closing channels...\n";
+}
+
+// Used to enter the receiving state
+void gmac::enter_receiving()
+{
+  d_us_rx->send(s_cmd_start_recv_raw_samples,
+             pmt_list2(PMT_F,
+                       d_us_rx_chan));
+
+  if(verbose)
+    std::cout << "[GMAC] Started RX sample stream\n";
+}
+
+// A simple idle state, nothing more to it.
+void gmac::enter_idle()
+{
+  d_state = IDLE;
+}
+
+// Handles the transmission of a pkt from the application.  The invocation
+// handle is passed on but a response is not given back to the application until
+// the response is passed from usrp_server.  This ensures that the MAC passes
+// back the success or failure.  Furthermore, the MAC could decide to retransmit
+// on a failure based on the result of the packet transmission.
+//
+// This should eventually be connected to a physically layer rather than
+// directly to usrp_server. (d_us_tx should be replaced with a different
+// connection)
+void gmac::handle_cmd_tx_pkt(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t dst = pmt_nth(1, data);
+  pmt_t samples = pmt_nth(2, data);
+  pmt_t pkt_properties = pmt_nth(3, data);
+
+  pmt_t us_tx_properties = pmt_make_dict();
+
+  // Set the packet to be carrier sensed?
+  if(carrier_sense_pkt(pkt_properties))
+    pmt_dict_set(us_tx_properties,
+                 pmt_intern("carrier-sense"),
+                 PMT_T);
+
+  pmt_t timestamp = pmt_from_long(0xffffffff);	// NOW
+
+  // Construct the proper message for USRP server
+  d_us_tx->send(s_cmd_xmit_raw_frame,
+                pmt_list5(invocation_handle,
+		                      d_us_tx_chan,
+		                      samples, 
+                          timestamp,
+                          us_tx_properties));
+
+  if(verbose && 0)
+    std::cout << "[GMAC] Transmitted packet\n";
+}
+
+// Handles a response from the USRP server about the transmission of a frame,
+// whether it was successful or failed.  This should eventually be replaced with
+// a response from the PHY layer.  This is where a retransmit could be
+// implemented.
+void gmac::handle_response_xmit_raw_frame(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t status = pmt_nth(1, data);
+
+  d_tx->send(s_response_tx_pkt,
+             pmt_list2(invocation_handle,
+                       status));
+}
+
+// This method determines whether carrier sense should be enabled based on two
+// properties.  The first is the MAC setting, which the user can set to carrier
+// sense packets by default or not.  The second is a per packet setting, which
+// can be used to override the MAC setting for the given packet only.
+bool gmac::carrier_sense_pkt(pmt_t pkt_properties) 
+{
+  // First we extract the per packet properties to check the per packet setting
+  // if it exists
+  if(pmt_is_dict(pkt_properties)) {
+
+    if(pmt_t pkt_cs = pmt_dict_ref(pkt_properties,
+                                   pmt_intern("carrier-sense"),
+                                   PMT_NIL)) {
+      // If the per packet property says true, enable carrier sense regardless
+      // of the MAC setting
+      if(pmt_eqv(pkt_cs, PMT_T))
+        return true;
+      // If the per packet setting says false, disable carrier sense regardless
+      // of the MAC setting
+      else if(pmt_eqv(pkt_cs, PMT_F))
+        return false;
+    }
+  }
+
+  // If we've hit this point, the packet properties did not state whether
+  // carrier sense should be used or not, so we use the MAC setting
+  if(d_carrier_sense)
+    return true;
+  else
+    return false;
+
+}
+
+// This method is envoked by an incoming cmd-enable-carrier-sense signal on the
+// C/S port.  It can be used to re-adjust the threshold or simply enabled
+// carrier sense.  When a threshold is not provided, the MAC will use an
+// averaging algorithm to determine the threshold (in the future).
+void gmac::handle_cmd_carrier_sense_enable(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t threshold = pmt_nth(1, data);
+  pmt_t deadline = pmt_nth(2, data);
+  long l_threshold, l_deadline;
+
+  // FIXME: for now, if threshold is NIL, we do not change the threshold.
+  // This should be replaced with an averaging algorithm
+  if(pmt_eqv(threshold, PMT_NIL))
+    l_threshold = d_cs_thresh;
+  else
+    l_threshold = pmt_to_long(threshold);
+
+  // If the deadline is NIL, we do not change the value
+  if(pmt_eqv(threshold, PMT_NIL))
+    l_deadline = d_cs_deadline;
+  else
+    l_deadline = pmt_to_long(deadline);
+  
+  set_carrier_sense(true, l_threshold, l_deadline, invocation_handle);
+}
+
+// This method is called when an incoming disable carrier sense command is sent
+// over the control status channel.  It so far does not ellicit a response, this
+// needs to be added correctly.  It needs to wait for the response for the C/S
+// packet from usrp_server.
+void gmac::handle_cmd_carrier_sense_disable(pmt_t data) 
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  
+  // We don't change the threshold, we leave it as is because the application
+  // did not request that it changes, only to disable carrier sense.
+  set_carrier_sense(false, d_cs_thresh, d_cs_deadline, invocation_handle);
+}
+
+// When the app requests that the threshold changes, the state of the carrier
+// sense should not change.  If it was enabled, it should remain enabled.
+// Likewise if it was disabled.  The deadline value should also remain
+// unchanged.
+void gmac::handle_cmd_carrier_sense_threshold(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t threshold = pmt_nth(1, data);
+  long l_threshold;
+
+  // FIXME: for now, if threshold is NIL, we do not change the threshold.
+  // This should be replaced with an averaging algorithm
+  if(pmt_eqv(threshold, PMT_NIL))
+    l_threshold = d_cs_thresh;
+  else
+    l_threshold = pmt_to_long(threshold);
+  
+  set_carrier_sense(d_carrier_sense, l_threshold, d_cs_deadline, invocation_handle);
+}
+
+// Ability to change the deadline using a C/S packet.  The state of all other
+// carrier sense parameters should not change.
+void gmac::handle_cmd_carrier_sense_deadline(pmt_t data)
+{
+  pmt_t invocation_handle = pmt_nth(0, data);
+  pmt_t deadline = pmt_nth(1, data);
+  long l_deadline;
+
+  // If the deadline passed is NIL, do *not* change the value.
+  if(pmt_eqv(deadline, PMT_NIL))
+    l_deadline = d_cs_deadline;
+  else
+    l_deadline = pmt_to_long(deadline);
+  
+  set_carrier_sense(d_carrier_sense, d_cs_thresh, l_deadline, invocation_handle);
+}
+
+REGISTER_MBLOCK_CLASS(gmac);
diff --git a/usrp/host/apps-inband/gmac.h b/usrp/host/apps-inband/gmac.h
new file mode 100644
index 0000000000..a6d0bcb128
--- /dev/null
+++ b/usrp/host/apps-inband/gmac.h
@@ -0,0 +1,91 @@
+/* -*- 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_GMAC_H
+#define INCLUDED_GMAC_H
+
+#include <mb_mblock.h>
+
+class gmac;
+
+class gmac : public mb_mblock
+{
+
+  // The state is used to determine how to handle incoming messages and of
+  // course, the state of the MAC protocol.
+  enum state_t {
+    INIT,
+    OPENING_USRP,
+    ALLOCATING_CHANNELS,
+    INIT_GMAC,
+    IDLE,
+    CLOSING_CHANNELS,
+    CLOSING_USRP,
+  };
+  state_t	d_state;
+
+  // Ports used for applications to connect to this block
+  mb_port_sptr		  d_tx, d_rx, d_cs;
+
+  // Ports to connect to usrp_server (us)
+  mb_port_sptr      d_us_tx, d_us_rx, d_us_cs;
+
+  // The channel numbers assigned for use
+  pmt_t d_us_rx_chan, d_us_tx_chan;
+
+  pmt_t d_which_usrp;
+
+  bool d_carrier_sense;
+  long d_cs_thresh;
+  long d_cs_deadline;
+
+  enum FPGA_REGISTERS {
+    REG_CS_THRESH = 1,
+    REG_CS_DEADLINE = 2
+  };
+  
+ public:
+  gmac(mb_runtime *rt, const std::string &instance_name, pmt_t user_arg);
+  ~gmac();
+  void handle_message(mb_message_sptr msg);
+
+ private:
+  void define_ports();
+  void initialize_usrp();
+  void initialize_gmac();
+  void set_carrier_sense(bool toggle, long threshold, long deadline, pmt_t invocation);
+  void allocate_channels();
+  void enter_receiving();
+  void enter_idle();
+  void close_channels();
+  void open_usrp();
+  void close_usrp();
+  void handle_cmd_tx_pkt(pmt_t data);
+  void handle_response_xmit_raw_frame(pmt_t data);
+  bool carrier_sense_pkt(pmt_t pkt_properties);
+  void handle_cmd_carrier_sense_enable(pmt_t data);
+  void handle_cmd_carrier_sense_threshold(pmt_t data);
+  void handle_cmd_carrier_sense_disable(pmt_t data);
+  void handle_cmd_carrier_sense_deadline(pmt_t data);
+ 
+};
+
+#endif // INCLUDED_GMAC_H
diff --git a/usrp/host/apps-inband/gmac.mbh b/usrp/host/apps-inband/gmac.mbh
new file mode 100644
index 0000000000..4fa9a062fd
--- /dev/null
+++ b/usrp/host/apps-inband/gmac.mbh
@@ -0,0 +1,146 @@
+;; -*- 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++.
+;; ----------------------------------------------------------------
+
+;; In the outgoing messages described below, invocation-handle is an
+;; identifier provided by the client to tag the method invocation.
+;; The identifier will be returned with the response, to provide the
+;; client with a mechanism to match asynchronous responses with the
+;; commands that generate them.  The value of the invocation-handle is
+;; opaque the the server, and is not required by the server to be
+;; unique.
+;;
+;; In the incoming messages described below, invocation-handle is the
+;; identifier provided by the client in the prompting invocation.  The
+;; identifier is returned with the response, so that the client has a
+;; mechanism to match asynchronous responses with the commands that
+;; generated them.
+;;
+;; status is either #t, indicating success, or a symbol indicating an error.
+;; All symbol's names shall begin with %error-
+
+
+;; ----------------------------------------------------------------
+;; gmac-tx
+;;
+;; The protocol class is defined from the client's point-of-view.
+;; (The client port is unconjugated, the server port is conjugated.)
+
+(define-protocol-class gmac-tx
+
+  (:outgoing
+
+    ;; Transmitting packets can carry an invocation handle so the application
+    ;; can get TX results on specific packets, such as whether a packet tagged
+    ;; as #1 was successfully transmitted or not.  This would allow the
+    ;; application to implement something sliding window like.
+    ;;
+    ;; 'dst' is the destination MAC address (given a MAC addressing scheme)
+    ;;
+    ;; 'data' will be treated transparently and passed on as samples.
+    ;;
+    ;; 'properties' can be used in the future to set per-packet options such as
+    ;;   carrier sense overriding functionality.
+    (cmd-tx-pkt invocation-handle dst data properties)
+
+   )
+
+  (:incoming
+
+    ;; The response will carry the same invocation-handle passed with cmd-tx-pkt
+    (response-tx-pkt invocation-handle status)
+
+   )
+  )
+
+;; ----------------------------------------------------------------
+;; gmac-rx
+;;
+;; The protocol class is defined from the client's point-of-view.
+;; (The client port is unconjugated, the server port is conjugated.)
+
+(define-protocol-class gmac-rx
+
+  (:outgoing
+    
+    ;; There are currently no outgoing commands, I believe that the RX
+    ;; should always be enabled, there is no point in having an enable/disable
+    ;; that I can see.
+   
+   )
+
+  (:incoming
+
+    ;; Contains packets decoded by the MAC destined for this machine, sent by
+    ;; the specified address.
+    (response-rx-pkt invocation-handle src data)
+
+   )
+  )
+
+
+;; ----------------------------------------------------------------
+;; gmac-cs
+;;
+;; The protocol class is defined from the client's point-of-view.
+;; (The client port is unconjugated, the server port is conjugated.)
+;;
+;; This defines a control/status interface to the MAC layer, for control over
+;; functionality such as carrier sense and future functionality such as channel
+;; hopping.
+
+
+(define-protocol-class gmac-cs
+
+  (:outgoing
+
+    ;; Threshold represents the carrier sense threshold based on the digital
+    ;; reading out of the DAC.  If the threshold is set to PMT_NIL then the
+    ;; MAC will use averaging to determine an appropriate threshold.
+    (cmd-carrier-sense-enable invocation-handle threshold deadline)
+    (cmd-carrier-sense-threshold invocation-handle threshold)
+    (cmd-carrier-sense-disable invocation-handle)
+
+    ;; Setting the number of fast transmission retries on a failure before
+    ;; reporting a loss back to the application.
+    (cmd-set-tx-retries invocation-handle retries)
+
+   )
+
+  (:incoming
+
+    (response-gmac-initialized invocation-handle status)
+
+    (response-carrier-sense-enable invocation-handle status)
+    (response-carrier-sense-threshold invocation-handle status)
+    (response-carrier-sense-deadline invocation-handle status)
+    (response-carrier-sense-disable invocation-handle status)
+
+    (response-set-tx-retries invocation-handle status)
+
+   )
+  )
diff --git a/usrp/host/apps-inband/gmac_symbols.h b/usrp/host/apps-inband/gmac_symbols.h
new file mode 100644
index 0000000000..0d7804be15
--- /dev/null
+++ b/usrp/host/apps-inband/gmac_symbols.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_GMAC_SYMBOLS_H
+#define INCLUDED_GMAC_SYMBOLS_H
+
+#include <pmt.h>
+
+// TX
+static pmt_t s_cmd_tx_pkt = pmt_intern("cmd-tx-pkt");
+static pmt_t s_response_tx_pkt = pmt_intern("response-tx-pkt");
+
+// RX
+static pmt_t s_response_rx_pkt = pmt_intern("response-rx-pkt");
+
+// CS
+static pmt_t s_cmd_carrier_sense_enable = pmt_intern("cmd-carrier-sense-enable");
+static pmt_t s_cmd_carrier_sense_threshold = pmt_intern("cmd-carrier-sense-threshold");
+static pmt_t s_cmd_carrier_sense_deadline = pmt_intern("cmd-carrier-sense-deadline");
+static pmt_t s_cmd_carrier_sense_disable = pmt_intern("cmd-carrier-sense-disable");
+static pmt_t s_cmd_set_tx_retries = pmt_intern("cmd-set-tx-retries");
+static pmt_t s_response_gmac_initialized = pmt_intern("response-gmac-initialized");
+static pmt_t s_response_carrier_sense_enable = pmt_intern("response-carrier-sense-enable");
+static pmt_t s_response_carrier_sense_treshold = pmt_intern("response-carrier-sense-threshold");
+static pmt_t s_response_carrier_sense_deadline = pmt_intern("response-carrier-sense-deadline");
+static pmt_t s_response_carrier_sense_disable = pmt_intern("response-carrier-sense-disable");
+static pmt_t s_response_set_tx_retries = pmt_intern("response-set-tx-retries");
+
+#endif // INCLUDED_GMAC_SYMBOLS_H
diff --git a/usrp/host/apps-inband/test_gmac_tx.cc b/usrp/host/apps-inband/test_gmac_tx.cc
new file mode 100644
index 0000000000..dd16c3fa18
--- /dev/null
+++ b/usrp/host/apps-inband/test_gmac_tx.cc
@@ -0,0 +1,332 @@
+/* -*- 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 <ui_nco.h>
+#include <gmac.h>
+#include <gmac_symbols.h>
+
+static bool verbose = true;
+
+class test_gmac_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,
+    TRANSMITTING,
+  };
+
+  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_gmac_tx(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~test_gmac_tx();
+  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_gmac_tx::test_gmac_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 * 4)),	// full packet
+    d_done_sending(false),
+    d_amplitude(16384)
+{ 
+  
+  define_component("GMAC", "gmac", PMT_NIL);
+  d_tx = define_port("tx0", "gmac-tx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "gmac-cs", false, mb_port::INTERNAL);
+
+  connect("self", "tx0", "GMAC", "tx0");
+  connect("self", "cs", "GMAC", "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_gmac_tx::~test_gmac_tx()
+{
+}
+
+void
+test_gmac_tx::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;
+  pmt_t dict = PMT_NIL;
+  std::string error_msg;
+
+  // Dispatch based on state
+  switch(d_state) {
+    
+    //------------------------------ INIT ---------------------------------//
+    // When GMAC is done initializing, it will send a response
+    case INIT:
+      
+      if(pmt_eq(event, s_response_gmac_initialized)) {
+        handle = pmt_nth(0, data);
+        status = pmt_nth(1, data);
+
+        if(pmt_eq(status, PMT_T)) {
+          enter_transmitting();
+          return;
+        }
+        else {
+          error_msg = "error initializing gmac:";
+          goto bail;
+        }
+      }
+      goto unhandled;
+
+    //-------------------------- TRANSMITTING ----------------------------//
+    // In the transmit state we count the number of underruns received and
+    // ballpark the number with an expected count (something >1 for starters)
+    case TRANSMITTING:
+      
+      // Check that the transmits are OK
+      if (pmt_eq(event, s_response_tx_pkt)){
+        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-tx-pkt:";
+          goto bail;
+        }
+      }
+
+      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, pmt_intern("%shutdown")))
+    std::cout << "[TEST_GMAC_TX] unhandled msg: " << msg
+              << "in state "<< d_state << std::endl;
+}
+
+void
+test_gmac_tx::enter_transmitting()
+{
+  d_state = TRANSMITTING;
+  d_nsamples_xmitted = 0;
+
+  d_cs->send(s_cmd_carrier_sense_deadline,
+             pmt_list2(PMT_NIL,
+                       pmt_from_long(50000000)));
+
+  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_gmac_tx::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();
+    }
+  }
+    
+  // Per packet properties
+  pmt_t tx_properties = pmt_make_dict();
+
+  if(d_nframes_xmitted > 25000) {
+    pmt_dict_set(tx_properties,
+                 pmt_intern("carrier-sense"),
+                 PMT_F);
+  }
+
+  if(d_nframes_xmitted > 35000) {
+    pmt_dict_set(tx_properties,
+                 pmt_intern("carrier-sense"),
+                 PMT_NIL);
+  }
+
+  if(d_nframes_xmitted == 45000) {
+    d_cs->send(s_cmd_carrier_sense_threshold, 
+               pmt_list2(PMT_NIL,
+                         pmt_from_long(100)));
+  }
+  
+  if(d_nframes_xmitted == 60000) {
+    d_cs->send(s_cmd_carrier_sense_threshold, 
+               pmt_list2(PMT_NIL,
+                         pmt_from_long(25)));
+  }
+  
+  if(d_nframes_xmitted == 75000) {
+    d_cs->send(s_cmd_carrier_sense_disable, 
+               pmt_list1(PMT_NIL));
+  }
+  
+  if(d_nframes_xmitted > 90000 && d_nframes_xmitted < 110000) {
+    pmt_dict_set(tx_properties,
+                 pmt_intern("carrier-sense"),
+                 PMT_T);
+  }
+  
+  if(d_nframes_xmitted > 110000) {
+
+    if(d_nframes_xmitted % 100 == 0)
+      pmt_dict_set(tx_properties,
+                   pmt_intern("carrier-sense"),
+                   PMT_T);
+}
+
+  pmt_t timestamp = pmt_from_long(0xffffffff);	// NOW
+  d_tx->send(s_cmd_tx_pkt,
+	     pmt_list4(PMT_NIL,   // invocation-handle
+           PMT_NIL,         // destination
+		       uvec,				    // the samples
+           tx_properties)); // per pkt properties
+
+  d_nsamples_xmitted += nsamples_this_frame;
+  d_nframes_xmitted++;
+
+  if(verbose && 0)
+    std::cout << "[TEST_GMAC_TX] Transmitted frame\n";
+}
+
+
+void
+test_gmac_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
+  }
+
+  build_and_send_next_frame();
+}
+
+REGISTER_MBLOCK_CLASS(test_gmac_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("test_gmac_tx", "test_gmac_tx", PMT_F, &result);
+}
diff --git a/usrp/host/apps-inband/test_usrp_inband_cs.cc b/usrp/host/apps-inband/test_usrp_inband_cs.cc
index 1d70341fe5..560b81aebb 100644
--- a/usrp/host/apps-inband/test_usrp_inband_cs.cc
+++ b/usrp/host/apps-inband/test_usrp_inband_cs.cc
@@ -34,12 +34,12 @@
 #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 <ui_nco.h>
 #include <symbols_usrp_server_cs.h>
 #include <symbols_usrp_channel.h>
 #include <symbols_usrp_low_level_cs.h>
@@ -138,7 +138,7 @@ test_usrp_cs::test_usrp_cs(mb_runtime *runtime, const std::string &instance_name
                pmt_from_long(128));
 
   pmt_dict_set(usrp_dict,
-               pmt_intern("interp-rx"),
+               pmt_intern("decim-rx"),
                pmt_from_long(16));
 
   // Specify the RBF to use
diff --git a/usrp/host/apps-inband/test_usrp_inband_overrun.cc b/usrp/host/apps-inband/test_usrp_inband_overrun.cc
new file mode 100644
index 0000000000..343720c28a
--- /dev/null
+++ b/usrp/host/apps-inband/test_usrp_inband_overrun.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 <iostream>
+#include <fstream>
+
+// 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_rx.h>
+
+static bool verbose = true;
+
+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
+
+  enum state_t {
+    INIT,
+    OPENING_USRP,
+    ALLOCATING_CHANNEL,
+    RECEIVING,
+    CLOSING_CHANNEL,
+    CLOSING_USRP,
+  };
+
+  state_t	d_state;
+
+  std::ofstream d_ofile;
+
+  long d_n_overruns;
+
+  long d_samples_recvd;
+  long d_samples_to_recv;
+
+ 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_n_overruns(0),
+    d_samples_recvd(0),
+    d_samples_to_recv(10e6)
+{ 
+  
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+  
+  // Pass a dictionary to usrp_server which specifies which interface to use, the stub or USRP
+  pmt_t usrp_dict = pmt_make_dict();
+
+  // Specify the RBF to use
+  pmt_dict_set(usrp_dict,
+               pmt_intern("rbf"),
+               pmt_intern("nanocell9.rbf"));
+
+  pmt_dict_set(usrp_dict,
+               pmt_intern("decim-rx"),
+               pmt_from_long(128));
+
+  define_component("server", "usrp_server", usrp_dict);
+
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+
+}
+
+test_usrp_rx::~test_usrp_rx()
+{
+}
+
+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){
+    
+    //----------------------------- 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);
+        if (pmt_eq(status, PMT_T)){
+          allocate_channel();
+          return;
+        }
+        else {
+          error_msg = "failed to open usrp:";
+          goto bail;
+        }
+      }
+      goto unhandled;
+      
+    //----------------------- ALLOCATING CHANNELS --------------------//
+    // Allocate an RX channel to perform the overrun test.
+    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;
+
+    //--------------------------- RECEIVING ------------------------------//
+    // In the receiving state, we receive samples until the specified amount
+    // while counting the number of overruns.
+    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;
+    
+    //------------------------- CLOSING CHANNEL ----------------------------//
+    // Check deallocation response for the RX channel 
+    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;
+        }
+      }
+
+      // Alternately, we ignore all response recv samples while waiting for the
+      // channel to actually close
+      if (pmt_eq(event, s_response_recv_raw_samples))
+        return;
+
+      goto unhandled;
+
+    //--------------------------- CLOSING USRP ------------------------------//
+    // Once we have received a successful USRP close response, we shutdown all
+    // mblocks and exit.
+    case CLOSING_USRP:
+      if (pmt_eq(event, s_response_close)){
+        status = pmt_nth(1, data);
+
+        if (pmt_eq(status, PMT_T)){
+          std::cout << "\nOverruns: " << d_n_overruns << std::endl;
+          fflush(stdout);
+          shutdown_all(PMT_T);
+          return;
+        }
+        else {
+          error_msg = "failed to close USRP:";
+          goto bail;
+        }
+      }
+      goto unhandled;
+
+    default:
+      goto unhandled;
+  }
+  return;
+
+ // 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, pmt_intern("%shutdown")))
+    std::cout << "test_usrp_inband_tx: 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;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_OVERRUN] Opening the USRP\n";
+}
+
+void
+test_usrp_rx::close_usrp()
+{
+  d_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
+  d_state = CLOSING_USRP;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_OVERRUN] Closing the USRP\n";
+}
+
+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;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_OVERRUN] Requesting RX channel allocation\n";
+}
+
+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));
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_OVERRUN] Receiving...\n";
+}
+
+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);
+
+  d_samples_recvd += pmt_length(v_samples) / 4;
+
+  // Check for overrun
+  if(!pmt_is_dict(properties)) {
+    std::cout << "[TEST_USRP_INBAND_OVERRUN] Recv samples dictionary is improper\n";
+    return;
+  }
+
+  if(pmt_t overrun = pmt_dict_ref(properties, 
+                                  pmt_intern("overrun"), 
+                                  PMT_NIL)) {
+    if(pmt_eqv(overrun, PMT_T)) {
+      d_n_overruns++;
+
+      if(verbose && 0)
+        std::cout << "[TEST_USRP_INBAND_OVERRUN] Underrun\n";
+    }
+    else {
+    if(verbose && 0)
+      std::cout << "[TEST_USRP_INBAND_OVERRUN] No overrun\n" << overrun <<std::endl;
+    }
+  } else {
+
+    if(verbose && 0)
+      std::cout << "[TEST_USRP_INBAND_OVERRUN] No overrun\n";
+  }
+
+  // Check if the number samples we have received meets the test
+  if(d_samples_recvd >= d_samples_to_recv) {
+    d_rx->send(s_cmd_stop_recv_raw_samples, pmt_list2(PMT_NIL, d_rx_chan));
+    enter_closing_channel();
+    return;
+  }
+
+}
+
+void
+test_usrp_rx::enter_closing_channel()
+{
+  d_state = CLOSING_CHANNEL;
+  
+  sleep(2);
+  
+  d_rx->send(s_cmd_deallocate_channel, pmt_list2(PMT_NIL, d_rx_chan));
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_OVERRUN] Deallocating RX channel\n";
+}
+
+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-inband/test_usrp_inband_ping.cc b/usrp/host/apps-inband/test_usrp_inband_ping.cc
index a68f492720..5a82f0c3cd 100644
--- a/usrp/host/apps-inband/test_usrp_inband_ping.cc
+++ b/usrp/host/apps-inband/test_usrp_inband_ping.cc
@@ -126,7 +126,7 @@ test_usrp_inband_ping::test_usrp_inband_ping(mb_runtime *runtime, const std::str
                pmt_from_long(128));
 
   pmt_dict_set(usrp_dict,
-               pmt_intern("interp-rx"),
+               pmt_intern("decim-rx"),
                pmt_from_long(16));
   
   d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
diff --git a/usrp/host/apps-inband/test_usrp_inband_registers.cc b/usrp/host/apps-inband/test_usrp_inband_registers.cc
index 922b6215d7..2ff42a052d 100644
--- a/usrp/host/apps-inband/test_usrp_inband_registers.cc
+++ b/usrp/host/apps-inband/test_usrp_inband_registers.cc
@@ -127,7 +127,7 @@ test_usrp_inband_registers::test_usrp_inband_registers(mb_runtime *runtime, cons
                pmt_from_long(128));
 
   pmt_dict_set(usrp_dict,
-               pmt_intern("interp-rx"),
+               pmt_intern("decim-rx"),
                pmt_from_long(16));
   
   d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
diff --git a/usrp/host/apps-inband/test_usrp_inband_rx.cc b/usrp/host/apps-inband/test_usrp_inband_rx.cc
index 4820c2d4ea..c37c19c005 100644
--- a/usrp/host/apps-inband/test_usrp_inband_rx.cc
+++ b/usrp/host/apps-inband/test_usrp_inband_rx.cc
@@ -39,32 +39,13 @@
 #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;
+// 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_rx.h>
+
+static bool verbose = true;
 
 class test_usrp_rx : public mb_mblock
 {
@@ -72,8 +53,6 @@ class test_usrp_rx : public mb_mblock
   mb_port_sptr 	d_cs;
   pmt_t		d_rx_chan;	// returned tx channel handle
 
-  bool d_disk_write;
-
   enum state_t {
     INIT,
     OPENING_USRP,
@@ -87,6 +66,9 @@ class test_usrp_rx : public mb_mblock
 
   std::ofstream d_ofile;
 
+  long d_samples_recvd;
+  long d_samples_to_recv;
+
  public:
   test_usrp_rx(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
   ~test_usrp_rx();
@@ -106,54 +88,34 @@ class test_usrp_rx : public mb_mblock
 
 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_samples_recvd(0),
+    d_samples_to_recv(5e6)
 { 
   
   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"));
+               pmt_intern("nanocell9.rbf"));
 
-  // Set TX and RX interpolations
   pmt_dict_set(usrp_dict,
-               pmt_intern("interp-tx"),
+               pmt_intern("decim-rx"),
                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
@@ -173,95 +135,119 @@ test_usrp_rx::handle_message(mb_message_sptr msg)
   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;
+    //----------------------------- 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);
+        if (pmt_eq(status, PMT_T)){
+          allocate_channel();
+          return;
+        }
+        else {
+          error_msg = "failed to open usrp:";
+          goto bail;
+        }
       }
-      else {
-        error_msg = "failed to allocate channel:";
-        goto bail;
+      goto unhandled;
+      
+    //----------------------- ALLOCATING CHANNELS --------------------//
+    // Allocate an RX channel to perform the overrun test.
+    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;
+      goto unhandled;
+
+    //--------------------------- RECEIVING ------------------------------//
+    // In the receiving state, we receive samples until the specified amount
+    // while counting the number of overruns.
+    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;
+        }
       }
-      else {
-        error_msg = "bad response-xmit-raw-frame:";
-        goto bail;
+      goto unhandled;
+    
+    //------------------------- CLOSING CHANNEL ----------------------------//
+    // Check deallocation response for the RX channel 
+    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_CHANNEL:
-    if (pmt_eq(event, s_response_deallocate_channel)){
-      status = pmt_nth(1, data);
-
-      if (pmt_eq(status, PMT_T)){
-        close_usrp();
+      // Alternately, we ignore all response recv samples while waiting for the
+      // channel to actually close
+      if (pmt_eq(event, s_response_recv_raw_samples))
         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;
+      goto unhandled;
+
+    //--------------------------- CLOSING USRP ------------------------------//
+    // Once we have received a successful USRP close response, we shutdown all
+    // mblocks and exit.
+    case CLOSING_USRP:
+      if (pmt_eq(event, s_response_close)){
+        status = pmt_nth(1, data);
+
+        if (pmt_eq(status, PMT_T)){
+          fflush(stdout);
+          shutdown_all(PMT_T);
+          return;
+        }
+        else {
+          error_msg = "failed to close USRP:";
+          goto bail;
+        }
       }
-      else {
-        error_msg = "failed to close USRP:";
-        goto bail;
-      }
-    }
-    goto unhandled;
+      goto unhandled;
 
-  default:
-    goto unhandled;
+    default:
+      goto unhandled;
   }
   return;
 
+ // 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:
-  std::cout << "test_usrp_inband_rx: unhandled msg: " << msg
-	    << "in state "<< d_state << std::endl;
+  if(verbose && !pmt_eq(event, pmt_intern("%shutdown")))
+    std::cout << "test_usrp_inband_tx: unhandled msg: " << msg
+              << "in state "<< d_state << std::endl;
 }
 
 
@@ -272,6 +258,9 @@ test_usrp_rx::open_usrp()
 
   d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, which_usrp));
   d_state = OPENING_USRP;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Opening the USRP\n";
 }
 
 void
@@ -279,6 +268,9 @@ test_usrp_rx::close_usrp()
 {
   d_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
   d_state = CLOSING_USRP;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Closing the USRP\n";
 }
 
 void
@@ -287,6 +279,9 @@ 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;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Requesting RX channel allocation\n";
 }
 
 void
@@ -297,6 +292,9 @@ test_usrp_rx::enter_receiving()
   d_rx->send(s_cmd_start_recv_raw_samples,
              pmt_list2(PMT_F,
                        d_rx_chan));
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Receiving...\n";
 }
 
 void
@@ -308,26 +306,20 @@ test_usrp_rx::handle_response_recv_raw_samples(pmt_t 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);
+  d_samples_recvd += pmt_length(v_samples) / 4;
 
-  if(d_disk_write)
-    d_ofile.write(samples, n_bytes);
+  // Check for overrun
+  if(!pmt_is_dict(properties)) {
+    std::cout << "[TEST_USRP_INBAND_RX] Recv samples dictionary is improper\n";
+    return;
+  }
 
-  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;
-    }
+  // Check if the number samples we have received meets the test
+  if(d_samples_recvd >= d_samples_to_recv) {
+    d_rx->send(s_cmd_stop_recv_raw_samples, pmt_list2(PMT_NIL, d_rx_chan));
+    enter_closing_channel();
+    return;
   }
-  
 
 }
 
@@ -336,7 +328,12 @@ test_usrp_rx::enter_closing_channel()
 {
   d_state = CLOSING_CHANNEL;
   
+  sleep(2);
+  
   d_rx->send(s_cmd_deallocate_channel, pmt_list2(PMT_NIL, d_rx_chan));
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Deallocating RX channel\n";
 }
 
 REGISTER_MBLOCK_CLASS(test_usrp_rx);
diff --git a/usrp/host/apps-inband/test_usrp_inband_timestamps.cc b/usrp/host/apps-inband/test_usrp_inband_timestamps.cc
index d48c2a7895..d24f5efc61 100644
--- a/usrp/host/apps-inband/test_usrp_inband_timestamps.cc
+++ b/usrp/host/apps-inband/test_usrp_inband_timestamps.cc
@@ -34,12 +34,12 @@
 #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 <ui_nco.h>
 #include <symbols_usrp_server_cs.h>
 #include <symbols_usrp_channel.h>
 #include <symbols_usrp_low_level_cs.h>
@@ -143,7 +143,7 @@ test_usrp_inband_timestamps::test_usrp_inband_timestamps(mb_runtime *runtime, co
                pmt_from_long(128));
 
   pmt_dict_set(usrp_dict,
-               pmt_intern("interp-rx"),
+               pmt_intern("decim-rx"),
                pmt_from_long(16));
 
   // Specify the RBF to use
diff --git a/usrp/host/apps-inband/test_usrp_inband_tx.cc b/usrp/host/apps-inband/test_usrp_inband_tx.cc
index 18d36213bb..6d269a4df5 100644
--- a/usrp/host/apps-inband/test_usrp_inband_tx.cc
+++ b/usrp/host/apps-inband/test_usrp_inband_tx.cc
@@ -34,11 +34,11 @@
 #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 <ui_nco.h>
 #include <symbols_usrp_server_cs.h>
 #include <symbols_usrp_channel.h>
 #include <symbols_usrp_low_level_cs.h>
@@ -121,7 +121,7 @@ test_usrp_tx::test_usrp_tx(mb_runtime *runtime, const std::string &instance_name
   // Specify the RBF to use
   pmt_dict_set(usrp_dict,
                pmt_intern("rbf"),
-               pmt_intern("boe3.rbf"));
+               pmt_intern("cs1.rbf"));
 
   // Set TX and RX interpolations
   pmt_dict_set(usrp_dict,
@@ -129,7 +129,7 @@ test_usrp_tx::test_usrp_tx(mb_runtime *runtime, const std::string &instance_name
                pmt_from_long(128));
 
   pmt_dict_set(usrp_dict,
-               pmt_intern("interp-rx"),
+               pmt_intern("decim-rx"),
                pmt_from_long(16));
   
   pmt_dict_set(usrp_dict,
@@ -298,13 +298,13 @@ test_usrp_tx::enter_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))))));
+  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(21))))));
 
   build_and_send_next_frame();	// fire off 4 to start pipeline
   build_and_send_next_frame();
@@ -357,12 +357,18 @@ test_usrp_tx::build_and_send_next_frame()
     }
   }
 
+  pmt_t tx_properties = pmt_make_dict();
+  pmt_dict_set(tx_properties,
+               pmt_intern("carrier-sense"),
+               PMT_T);
+
   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
+	     pmt_list5(pmt_from_long(d_nframes_xmitted),  // invocation-handle
 		       d_tx_chan,			  // channel
 		       uvec,				  // the samples
-		       timestamp));
+		       timestamp,
+           tx_properties));
 
   d_nsamples_xmitted += nsamples_this_frame;
   d_nframes_xmitted++;
diff --git a/usrp/host/apps-inband/test_usrp_inband_underrun.cc b/usrp/host/apps-inband/test_usrp_inband_underrun.cc
index 61ea962371..411e88777b 100644
--- a/usrp/host/apps-inband/test_usrp_inband_underrun.cc
+++ b/usrp/host/apps-inband/test_usrp_inband_underrun.cc
@@ -129,7 +129,7 @@ test_usrp_inband_underrun::test_usrp_inband_underrun(mb_runtime *runtime, const
   d_rx_chan(PMT_NIL),
   d_which_usrp(pmt_from_long(0)),
   d_state(INIT),
-  d_nsamples_to_send((long) 50e6),
+  d_nsamples_to_send((long) 20e6),
   d_nsamples_xmitted(0),
   d_nframes_xmitted(0),
   d_samples_per_frame(d_nsamples_to_send),	// full packet
@@ -145,16 +145,16 @@ test_usrp_inband_underrun::test_usrp_inband_underrun(mb_runtime *runtime, const
   // Specify the RBF to use
   pmt_dict_set(usrp_dict,
                pmt_intern("rbf"),
-               pmt_intern("merge4.rbf"));
+               pmt_intern("nanocell9.rbf"));
 
   // Set TX and RX interpolations
   pmt_dict_set(usrp_dict,
                pmt_intern("interp-tx"),
-               pmt_from_long(16));
+               pmt_from_long(8));
 
   pmt_dict_set(usrp_dict,
-               pmt_intern("interp-rx"),
-               pmt_from_long(16));
+               pmt_intern("decim-rx"),
+               pmt_from_long(128));
   
   d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
   d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
@@ -265,7 +265,7 @@ test_usrp_inband_underrun::handle_message(mb_message_sptr msg)
           // If the RX has also been allocated already, we can continue
           if(!pmt_eqv(d_rx_chan, PMT_NIL)) {
             enter_receiving();
-            //enter_transmitting();
+            enter_transmitting();
           }
 
           return;
@@ -294,7 +294,7 @@ test_usrp_inband_underrun::handle_message(mb_message_sptr msg)
           // If the TX has also been allocated already, we can continue
           if(!pmt_eqv(d_tx_chan, PMT_NIL)) {
             enter_receiving();
-            //enter_transmitting();
+            enter_transmitting();
           }
 
           return;
@@ -409,6 +409,7 @@ test_usrp_inband_underrun::handle_message(mb_message_sptr msg)
             std::cout << "[TEST_USRP_INBAND_UNDERRUN] Successfully closed USRP\n";
 
           std::cout << "\nUnderruns: " << d_n_underruns << std::endl;
+          fflush(stdout);
 
           shutdown_all(PMT_T);
           return;
@@ -616,9 +617,9 @@ void
 test_usrp_inband_underrun::handle_xmit_response(pmt_t handle)
 {
   if (d_done_sending &&
-      pmt_to_long(handle) == (d_nframes_xmitted - 1)){
+    pmt_to_long(handle) == (d_nframes_xmitted - 1)){
     // We're done sending and have received all responses
-    //closing_channels();
+    closing_channels();
     return;
   }
 
@@ -637,14 +638,19 @@ test_usrp_inband_underrun::handle_recv_response(pmt_t dict)
   if(pmt_t underrun = pmt_dict_ref(dict, 
                                   pmt_intern("underrun"), 
                                   PMT_NIL)) {
-    if(pmt_eqv(underrun, PMT_T)) 
+    if(pmt_eqv(underrun, PMT_T)) {
       d_n_underruns++;
 
-    if(verbose)
-      std::cout << "[TEST_USRP_INBAND_UNDERRUN] Underrun\n";
+      if(verbose && 0)
+        std::cout << "[TEST_USRP_INBAND_UNDERRUN] Underrun\n";
+    }
+    else {
+    if(verbose && 0)
+      std::cout << "[TEST_USRP_INBAND_UNDERRUN] No underrun\n" << underrun <<std::endl;
+    }
   } else {
 
-    if(verbose)
+    if(verbose && 0)
       std::cout << "[TEST_USRP_INBAND_UNDERRUN] No underrun\n";
   }
   
@@ -664,6 +670,8 @@ test_usrp_inband_underrun::closing_usrp()
 {
   d_state = CLOSING_USRP;
 
+  sleep(2);
+
   d_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
 }
 
diff --git a/usrp/host/apps-inband/time_stuff.c b/usrp/host/apps-inband/time_stuff.c
deleted file mode 100644
index 89a4a38151..0000000000
--- a/usrp/host/apps-inband/time_stuff.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/* -*- c++ -*- */
-/*
- * Copyright 2003 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
-
-#include "time_stuff.h"
-
-#include <sys/time.h>
-#ifdef HAVE_SYS_RESOURCE_H
-#include <sys/resource.h>
-#endif
-#include <unistd.h>
-
-static double
-timeval_to_secs (struct timeval *tv)
-{
-  return (double) tv->tv_sec + (double) tv->tv_usec * 1e-6;
-}
-
-double
-get_cpu_usage (void)
-{
-#ifdef HAVE_GETRUSAGE
-  struct rusage	ru;
-
-  if (getrusage (RUSAGE_SELF, &ru) != 0)
-    return 0;
-
-  return timeval_to_secs (&ru.ru_utime) + timeval_to_secs (&ru.ru_stime);
-#else
-  return 0;	/* FIXME */
-#endif
-}
-
-/*
- * return elapsed time (wall time) in seconds
- */
-double
-get_elapsed_time (void)
-{
-  struct timeval	tv;
-  if (gettimeofday (&tv, 0) != 0)
-    return 0;
-
-  return timeval_to_secs (&tv);
-}
-
diff --git a/usrp/host/apps-inband/time_stuff.h b/usrp/host/apps-inband/time_stuff.h
deleted file mode 100644
index 74b79f388e..0000000000
--- a/usrp/host/apps-inband/time_stuff.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* -*- c++ -*- */
-/*
- * Copyright 2003 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 _TIME_STUFF_H_
-#define _TIME_STUFF_H_
-
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * return USER + SYS cpu time in seconds
- */
-double get_cpu_usage (void);
-
-/*
- * return elapsed time in seconds
- */
-double get_elapsed_time (void);
- 
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* _TIME_STUFF_H_ */
diff --git a/usrp/host/apps-inband/ui_sincos.c b/usrp/host/apps-inband/ui_sincos.c
index 36ca89c7dd..27841f0100 100644
--- a/usrp/host/apps-inband/ui_sincos.c
+++ b/usrp/host/apps-inband/ui_sincos.c
@@ -26,7 +26,7 @@
 
 #define _GNU_SOURCE		// ask for GNU extensions if available
 
-#include <ui_sincos.h>
+#include "ui_sincos.h"
 #include <math.h>
 
 // ----------------------------------------------------------------
diff --git a/usrp/host/lib/inband/usrp_inband_usb_packet.h b/usrp/host/lib/inband/usrp_inband_usb_packet.h
index 9290f55ae5..8c19b1aeba 100644
--- a/usrp/host/lib/inband/usrp_inband_usb_packet.h
+++ b/usrp/host/lib/inband/usrp_inband_usb_packet.h
@@ -64,8 +64,9 @@ public:
     FL_DROPPED        = 0x20000000,
     FL_START_OF_BURST = 0x10000000,
     FL_END_OF_BURST   = 0x08000000,
+    FL_CARRIER_SENSE  = 0x04000000,
 
-    FL_ALL_FLAGS      = 0xf8000000
+    FL_ALL_FLAGS      = 0xfc000000
   };
 
   static const int FL_OVERRUN_SHIFT = 31;
diff --git a/usrp/host/lib/inband/usrp_rx.cc b/usrp/host/lib/inband/usrp_rx.cc
index 7344a6e898..caa2d71754 100644
--- a/usrp/host/lib/inband/usrp_rx.cc
+++ b/usrp/host/lib/inband/usrp_rx.cc
@@ -119,7 +119,7 @@ usrp_rx::read_and_respond(pmt_t data)
       return;
     }
 
-    if(underrun)
+    if(underrun && verbose && 0)
       std::cout << "[usrp_rx] Underrun\n";
 
     d_cs->send(s_response_usrp_rx_read, 
diff --git a/usrp/host/lib/inband/usrp_rx_stub.cc b/usrp/host/lib/inband/usrp_rx_stub.cc
index bf78ddf27a..5ea8135aaf 100644
--- a/usrp/host/lib/inband/usrp_rx_stub.cc
+++ b/usrp/host/lib/inband/usrp_rx_stub.cc
@@ -33,7 +33,7 @@
 #include <fpga_regs_common.h>
 #include "usrp_standard.h"
 #include <stdio.h>
-#include "ui_nco.h"
+#include <ui_nco.h>
 #include <fstream>
 
 #include <symbols_usrp_rx_cs.h>
diff --git a/usrp/host/lib/inband/usrp_rx_stub.h b/usrp/host/lib/inband/usrp_rx_stub.h
index 483af5b487..5a75bf00ac 100644
--- a/usrp/host/lib/inband/usrp_rx_stub.h
+++ b/usrp/host/lib/inband/usrp_rx_stub.h
@@ -24,7 +24,7 @@
 #include <mb_mblock.h>
 #include <vector>
 #include "usrp_standard.h"
-#include "ui_nco.h"
+#include <ui_nco.h>
 #include <fstream>
 #include <queue>
 #include <usrp_inband_usb_packet.h>
diff --git a/usrp/host/lib/inband/usrp_server.cc b/usrp/host/lib/inband/usrp_server.cc
index 760397dc75..d73c7d5253 100644
--- a/usrp/host/lib/inband/usrp_server.cc
+++ b/usrp/host/lib/inband/usrp_server.cc
@@ -53,6 +53,8 @@ usrp_server::usrp_server(mb_runtime *rt, const std::string &instance_name, pmt_t
   : mb_mblock(rt, instance_name, user_arg),
   d_fake_rx(false)
 {
+  if(verbose)
+    std::cout << "[USRP_SERVER] Initializing...\n";
 
   // Dictionary for arguments to all of the components
   pmt_t usrp_dict = user_arg;
@@ -596,11 +598,26 @@ void usrp_server::handle_cmd_xmit_raw_frame(mb_port_sptr port, std::vector<struc
   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));
+  pmt_t properties = pmt_nth(4, 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;
+
+  // Read information from the properties of the packet
+  bool carrier_sense = false;
+  if(pmt_is_dict(properties)) {
+
+    // Check if carrier sense is enabled for the frame
+    if(pmt_t p_carrier_sense = pmt_dict_ref(properties, 
+                                            pmt_intern("carrier-sense"), 
+                                            PMT_NIL)) {
+      if(pmt_eqv(p_carrier_sense, PMT_T)) 
+        carrier_sense = true;
+    }
+  }
+
   
   // 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
@@ -619,8 +636,16 @@ void usrp_server::handle_cmd_xmit_raw_frame(mb_port_sptr port, std::vector<struc
       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);
+      
+      if(carrier_sense)
+        pkts[n].set_header(pkts[n].FL_START_OF_BURST 
+                           | pkts[n].FL_CARRIER_SENSE, 
+                           channel, 0, payload_len);
+      else
+        pkts[n].set_header(pkts[n].FL_START_OF_BURST, channel, 0, payload_len);
+
       pkts[n].set_timestamp(timestamp);
+    
     } else {
       pkts[n].set_header(0, channel, 0, payload_len);
       pkts[n].set_timestamp(0xffffffff);
@@ -635,7 +660,7 @@ void usrp_server::handle_cmd_xmit_raw_frame(mb_port_sptr port, std::vector<struc
 
   pkts[n_packets-1].set_end_of_burst(); // set the last packet's end of burst
 
-  if (verbose)
+  if (verbose && 0)
     std::cout << "[USRP_SERVER] Received raw frame invocation: " 
               << invocation_handle << std::endl;
     
diff --git a/usrp/host/lib/inband/usrp_server.mbh b/usrp/host/lib/inband/usrp_server.mbh
index 06ec4b996a..3fd0db139b 100644
--- a/usrp/host/lib/inband/usrp_server.mbh
+++ b/usrp/host/lib/inband/usrp_server.mbh
@@ -106,7 +106,7 @@
 ;;   (op-ping-fixed-reply rid ping-value)
 ;;   (op-write-reg reg-number reg-value)
 ;;   (op-write-reg-masked reg-number reg-value mask-value)
-;;   (op-read-reg rid reg-number reg-value)
+;;   (op-read-reg rid reg-number)
 ;;   (op-read-reg-reply rid reg-number reg-value)
 ;;   (op-i2c-write i2c-addr u8-vec)
 ;;   (op-i2c-read rid i2c-addr nbytes)
@@ -144,7 +144,7 @@
 
   (:outgoing
 
-   (cmd-xmit-raw-frame invocation-handle channel samples timestamp)
+   (cmd-xmit-raw-frame invocation-handle channel samples timestamp properties)
 
    ;; The argument channel must be an integer.  It specifies the
    ;; channel on which the frame of samples will be be sent.
diff --git a/usrp/host/lib/inband/usrp_usb_interface.cc b/usrp/host/lib/inband/usrp_usb_interface.cc
index b2ccba81b8..269ed2706d 100644
--- a/usrp/host/lib/inband/usrp_usb_interface.cc
+++ b/usrp/host/lib/inband/usrp_usb_interface.cc
@@ -53,8 +53,8 @@ usrp_usb_interface::usrp_usb_interface(mb_runtime *rt, const std::string &instan
   : mb_mblock(rt, instance_name, user_arg),
   d_fpga_debug(false),
   d_fake_usrp(false),
-  d_interp_tx(16),
-  d_interp_rx(16),
+  d_interp_tx(128),
+  d_decim_rx(128),
   d_rf_freq(10e6),
   d_rbf("inband_tx_rx.rbf")
 {
@@ -87,11 +87,11 @@ usrp_usb_interface::usrp_usb_interface(mb_runtime *rt, const std::string &instan
     }
     
     // Read the RX interpolations
-    if(pmt_t interp_rx = pmt_dict_ref(usrp_dict, 
-                                      pmt_intern("interp-rx"), 
+    if(pmt_t decim_rx = pmt_dict_ref(usrp_dict, 
+                                      pmt_intern("decim-rx"), 
                                       PMT_NIL)) {
-      if(!pmt_eqv(interp_rx, PMT_NIL)) 
-        d_interp_rx = pmt_to_long(interp_rx);
+      if(!pmt_eqv(decim_rx, PMT_NIL)) 
+        d_decim_rx = pmt_to_long(decim_rx);
     }
 
     // Read the RBF
@@ -119,7 +119,7 @@ usrp_usb_interface::usrp_usb_interface(mb_runtime *rt, const std::string &instan
               << d_interp_tx << std::endl;
           
     std::cout << "[USRP_USB_INTERFACE] Setting RX interpolation to " 
-              << d_interp_rx << std::endl;
+              << d_decim_rx << std::endl;
 
     std::cout << "[USRP_USB_INTERFACE] Using TX interface: " 
               << tx_interface << "\n";
@@ -305,7 +305,7 @@ usrp_usb_interface::handle_cmd_open(pmt_t data)
 
   d_urx =
     usrp_standard_rx::make (which_usrp,
-			    d_interp_rx,		
+			    d_decim_rx,		
 			    1,		        // nchan
 			    -1,           // mux
 			    0,            // set blank mode to start
diff --git a/usrp/host/lib/inband/usrp_usb_interface.h b/usrp/host/lib/inband/usrp_usb_interface.h
index 42cda7af15..8efce2ff66 100644
--- a/usrp/host/lib/inband/usrp_usb_interface.h
+++ b/usrp/host/lib/inband/usrp_usb_interface.h
@@ -47,7 +47,7 @@ class usrp_usb_interface : public mb_mblock
   bool d_fake_usrp;
 
   long d_interp_tx;
-  long d_interp_rx;
+  long d_decim_rx;
 
   long d_rf_freq;