Merge branch 'master' of git@ettus.sourcerepo.com:ettus/uhd into rfx

16 files changed, 312 insertions, 344 deletions

diff --git a/host/lib/device.cpp b/host/lib/device.cpp
index 27a365d34..0197a6232 100644
--- a/host/lib/device.cpp
+++ b/host/lib/device.cpp
@@ -42,7 +42,7 @@ static size_t hash_device_addr(
     const device_addr_t &dev_addr
 ){
     //sort the keys of the device address
-    std::vector<std::string> keys = dev_addr.get_keys();
+    std::vector<std::string> keys = dev_addr.keys();
     std::sort(keys.begin(), keys.end());
 
     //combine the hashes of sorted keys/value pairs
@@ -99,7 +99,7 @@ device::sptr device::make(const device_addr_t &hint, size_t which){
         BOOST_FOREACH(device_addr_t dev_addr, fcn.get<0>()(hint)){
             //copy keys that were in hint but not in dev_addr
             //this way, we can pass additional transport arguments
-            BOOST_FOREACH(const std::string &key, hint.get_keys()){
+            BOOST_FOREACH(const std::string &key, hint.keys()){
                 if (not dev_addr.has_key(key)) dev_addr[key] = hint[key];
             }
             //append the discovered address and its factory function
diff --git a/host/lib/load_modules.cpp b/host/lib/load_modules.cpp
index babff1ca5..ef633325d 100644
--- a/host/lib/load_modules.cpp
+++ b/host/lib/load_modules.cpp
@@ -31,6 +31,7 @@ namespace fs = boost::filesystem;
  **********************************************************************/
 #ifdef HAVE_DLFCN_H
 #include <dlfcn.h>
+static const std::string env_path_sep = ":";
 
 static void load_module(const std::string &file_name){
     if (dlopen(file_name.c_str(), RTLD_LAZY) == NULL){
@@ -42,6 +43,7 @@ static void load_module(const std::string &file_name){
 
 #elif HAVE_WINDOWS_H
 #include <windows.h>
+static const std::string env_path_sep = ";";
 
 static void load_module(const std::string &file_name){
     if (LoadLibrary(file_name.c_str()) == NULL){
@@ -52,6 +54,7 @@ static void load_module(const std::string &file_name){
 }
 
 #else
+static const std::string env_path_sep = ":";
 
 static void load_module(const std::string &file_name){
     throw std::runtime_error(str(
@@ -108,7 +111,7 @@ UHD_STATIC_BLOCK(load_modules){
 
     //split the path at the path separators
     std::vector<std::string> module_paths;
-    boost::split(module_paths, env_module_path, boost::is_any_of(":;"));
+    boost::split(module_paths, env_module_path, boost::is_any_of(env_path_sep));
 
     //load modules in each path
     BOOST_FOREACH(const std::string &module_path, module_paths){
diff --git a/host/lib/types.cpp b/host/lib/types.cpp
index bf9f8b895..61a63b710 100644
--- a/host/lib/types.cpp
+++ b/host/lib/types.cpp
@@ -71,9 +71,9 @@ clock_config_t::clock_config_t(void){
 /***********************************************************************
  * stream command
  **********************************************************************/
-stream_cmd_t::stream_cmd_t(void){
+stream_cmd_t::stream_cmd_t(const stream_mode_t &stream_mode_){
+    stream_mode = stream_mode_;
     stream_now = true;
-    continuous = false;
     num_samps = 0;
 }
 
@@ -85,7 +85,8 @@ rx_metadata_t::rx_metadata_t(void){
     has_stream_id = false;
     time_spec = time_spec_t();
     has_time_spec = false;
-    is_fragment = false;
+    more_fragments = false;
+    fragment_offset = 0;
 }
 
 tx_metadata_t::tx_metadata_t(void){
@@ -121,7 +122,7 @@ time_spec_t::time_spec_t(boost::posix_time::ptime time, double tick_rate){
 std::string device_addr_t::to_string(void) const{
     const device_addr_t &device_addr = *this;
     std::stringstream ss;
-    BOOST_FOREACH(std::string key, device_addr.get_keys()){
+    BOOST_FOREACH(std::string key, device_addr.keys()){
         ss << boost::format("%s: %s") % key % device_addr[key] << std::endl;
     }
     return ss.str();
@@ -137,7 +138,7 @@ static std::string trim(const std::string &in){
 std::string device_addr_t::to_args_str(void) const{
     std::string args_str;
     const device_addr_t &device_addr = *this;
-    BOOST_FOREACH(const std::string &key, device_addr.get_keys()){
+    BOOST_FOREACH(const std::string &key, device_addr.keys()){
         args_str += key + pair_delim + device_addr[key] + arg_delim;
     }
     return args_str;
diff --git a/host/lib/usrp/dboard/db_basic_and_lf.cpp b/host/lib/usrp/dboard/db_basic_and_lf.cpp
index 2f6890b25..5a992339b 100644
--- a/host/lib/usrp/dboard/db_basic_and_lf.cpp
+++ b/host/lib/usrp/dboard/db_basic_and_lf.cpp
@@ -87,8 +87,6 @@ UHD_STATIC_BLOCK(reg_basic_and_lf_dboards){
  **********************************************************************/
 basic_rx::basic_rx(ctor_args_t const& args, double max_freq) : rx_dboard_base(args){
     _max_freq = max_freq;
-    // set the gpios to safe values (all inputs)
-    get_interface()->set_gpio_ddr(dboard_interface::GPIO_BANK_RX, 0x0000);
 }
 
 basic_rx::~basic_rx(void){
@@ -145,8 +143,14 @@ void basic_rx::rx_get(const wax::obj &key_, wax::obj &val){
         return;
 
     case SUBDEV_PROP_IQ_SWAPPED:
+        val = false;
+        return;
+
     case SUBDEV_PROP_SPECTRUM_INVERTED:
-    case SUBDEV_PROP_LO_INTERFERES:
+        val = false;
+        return;
+
+    case SUBDEV_PROP_USE_LO_OFFSET:
         val = false;
         return;
     }
@@ -170,17 +174,7 @@ void basic_rx::rx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_FREQ:
         return; // it wont do you much good, but you can set it
 
-    case SUBDEV_PROP_NAME:
-    case SUBDEV_PROP_OTHERS:
-    case SUBDEV_PROP_GAIN_RANGE:
-    case SUBDEV_PROP_GAIN_NAMES:
-    case SUBDEV_PROP_FREQ_RANGE:
-    case SUBDEV_PROP_ANTENNA_NAMES:
-    case SUBDEV_PROP_QUADRATURE:
-    case SUBDEV_PROP_IQ_SWAPPED:
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-    case SUBDEV_PROP_LO_INTERFERES:
-        throw std::runtime_error(str(boost::format(
+    default: throw std::runtime_error(str(boost::format(
             "Error: trying to set read-only property on %s subdev"
         ) % dboard_id::to_string(get_rx_id())));
     }
@@ -191,8 +185,6 @@ void basic_rx::rx_set(const wax::obj &key_, const wax::obj &val){
  **********************************************************************/
 basic_tx::basic_tx(ctor_args_t const& args, double max_freq) : tx_dboard_base(args){
     _max_freq = max_freq;
-    // set the gpios to safe values (all inputs)
-    get_interface()->set_gpio_ddr(dboard_interface::GPIO_BANK_TX, 0x0000);
 }
 
 basic_tx::~basic_tx(void){
@@ -246,8 +238,14 @@ void basic_tx::tx_get(const wax::obj &key_, wax::obj &val){
         return;
 
     case SUBDEV_PROP_IQ_SWAPPED:
+        val = false;
+        return;
+
     case SUBDEV_PROP_SPECTRUM_INVERTED:
-    case SUBDEV_PROP_LO_INTERFERES:
+        val = false;
+        return;
+
+    case SUBDEV_PROP_USE_LO_OFFSET:
         val = false;
         return;
     }
@@ -271,17 +269,7 @@ void basic_tx::tx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_FREQ:
         return; // it wont do you much good, but you can set it
 
-    case SUBDEV_PROP_NAME:
-    case SUBDEV_PROP_OTHERS:
-    case SUBDEV_PROP_GAIN_RANGE:
-    case SUBDEV_PROP_GAIN_NAMES:
-    case SUBDEV_PROP_FREQ_RANGE:
-    case SUBDEV_PROP_ANTENNA_NAMES:
-    case SUBDEV_PROP_QUADRATURE:
-    case SUBDEV_PROP_IQ_SWAPPED:
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-    case SUBDEV_PROP_LO_INTERFERES:
-        throw std::runtime_error(str(boost::format(
+    default: throw std::runtime_error(str(boost::format(
             "Error: trying to set read-only property on %s subdev"
         ) % dboard_id::to_string(get_tx_id())));
     }
diff --git a/host/lib/usrp/dboard_manager.cpp b/host/lib/usrp/dboard_manager.cpp
index 3a5cf3a35..4cf2e5820 100644
--- a/host/lib/usrp/dboard_manager.cpp
+++ b/host/lib/usrp/dboard_manager.cpp
@@ -250,11 +250,11 @@ dboard_manager_impl::~dboard_manager_impl(void){
 }
 
 prop_names_t dboard_manager_impl::get_rx_subdev_names(void){
-    return _rx_dboards.get_keys();
+    return _rx_dboards.keys();
 }
 
 prop_names_t dboard_manager_impl::get_tx_subdev_names(void){
-    return _tx_dboards.get_keys();
+    return _tx_dboards.keys();
 }
 
 wax::obj dboard_manager_impl::get_rx_subdev(const std::string &subdev_name){
diff --git a/host/lib/usrp/simple_usrp.cpp b/host/lib/usrp/simple_usrp.cpp
index a0551a630..fb3cc8eec 100644
--- a/host/lib/usrp/simple_usrp.cpp
+++ b/host/lib/usrp/simple_usrp.cpp
@@ -22,6 +22,7 @@
 #include <uhd/usrp/mboard_props.hpp>
 #include <uhd/usrp/device_props.hpp>
 #include <uhd/usrp/dboard_props.hpp>
+#include <uhd/usrp/dsp_props.hpp>
 #include <boost/foreach.hpp>
 #include <boost/format.hpp>
 #include <stdexcept>
@@ -30,17 +31,6 @@ using namespace uhd;
 using namespace uhd::usrp;
 
 /***********************************************************************
- * Helper Functions
- **********************************************************************/
-static std::vector<double> get_xx_rates(wax::obj decerps, wax::obj rate){
-    std::vector<double> rates;
-    BOOST_FOREACH(size_t decerp, decerps.as<std::vector<size_t> >()){
-        rates.push_back(rate.as<double>()/decerp);
-    }
-    return rates;
-}
-
-/***********************************************************************
  * Simple Device Implementation
  **********************************************************************/
 class simple_usrp_impl : public simple_usrp{
@@ -48,8 +38,8 @@ public:
     simple_usrp_impl(const device_addr_t &addr){
         _dev = device::make(addr);
         _mboard = (*_dev)[DEVICE_PROP_MBOARD];
-        _rx_ddc = _mboard[named_prop_t(MBOARD_PROP_RX_DSP, "ddc0")];
-        _tx_duc = _mboard[named_prop_t(MBOARD_PROP_TX_DSP, "duc0")];
+        _rx_dsp = _mboard[MBOARD_PROP_RX_DSP];
+        _tx_dsp = _mboard[MBOARD_PROP_TX_DSP];
 
         //extract rx subdevice
         wax::obj rx_dboard = _mboard[MBOARD_PROP_RX_DBOARD];
@@ -86,7 +76,7 @@ public:
     }
 
     void issue_stream_cmd(const stream_cmd_t &stream_cmd){
-        _rx_ddc[std::string("stream_cmd")] = stream_cmd;
+        _mboard[MBOARD_PROP_STREAM_CMD] = stream_cmd;
     }
 
     void set_clock_config(const clock_config_t &clock_config){
@@ -101,21 +91,15 @@ public:
      * RX methods
      ******************************************************************/
     void set_rx_rate(double rate){
-        double samp_rate = _rx_ddc[std::string("if_rate")].as<double>();
-        assert_has(get_rx_rates(), rate, "simple device rx rate");
-        _rx_ddc[std::string("decim")] = size_t(samp_rate/rate);
+        _rx_dsp[DSP_PROP_HOST_RATE] = rate;
     }
 
     double get_rx_rate(void){
-        return _rx_ddc[std::string("bb_rate")].as<double>();
-    }
-
-    std::vector<double> get_rx_rates(void){
-        return get_xx_rates(_rx_ddc[std::string("decims")], _rx_ddc[std::string("if_rate")]);
+        return _rx_dsp[DSP_PROP_HOST_RATE].as<double>();
     }
 
     tune_result_t set_rx_freq(double target_freq){
-        return tune_rx_subdev_and_ddc(_rx_subdev, _rx_ddc, target_freq);
+        return tune_rx_subdev_and_ddc(_rx_subdev, _rx_dsp, target_freq);
     }
 
     freq_range_t get_rx_freq_range(void){
@@ -150,21 +134,15 @@ public:
      * TX methods
      ******************************************************************/
     void set_tx_rate(double rate){
-        double samp_rate = _tx_duc[std::string("if_rate")].as<double>();
-        assert_has(get_tx_rates(), rate, "simple device tx rate");
-        _tx_duc[std::string("interp")] = size_t(samp_rate/rate);
+        _tx_dsp[DSP_PROP_HOST_RATE] = rate;
     }
 
     double get_tx_rate(void){
-        return _tx_duc[std::string("bb_rate")].as<double>();
-    }
-
-    std::vector<double> get_tx_rates(void){
-        return get_xx_rates(_tx_duc[std::string("interps")], _tx_duc[std::string("if_rate")]);
+        return _tx_dsp[DSP_PROP_HOST_RATE].as<double>();
     }
 
     tune_result_t set_tx_freq(double target_freq){
-        return tune_tx_subdev_and_duc(_tx_subdev, _tx_duc, target_freq);
+        return tune_tx_subdev_and_duc(_tx_subdev, _tx_dsp, target_freq);
     }
 
     freq_range_t get_tx_freq_range(void){
@@ -198,8 +176,8 @@ public:
 private:
     device::sptr _dev;
     wax::obj _mboard;
-    wax::obj _rx_ddc;
-    wax::obj _tx_duc;
+    wax::obj _rx_dsp;
+    wax::obj _tx_dsp;
     wax::obj _rx_subdev;
     wax::obj _tx_subdev;
 };
diff --git a/host/lib/usrp/tune_helper.cpp b/host/lib/usrp/tune_helper.cpp
index 79a6aff7b..2fb15064c 100644
--- a/host/lib/usrp/tune_helper.cpp
+++ b/host/lib/usrp/tune_helper.cpp
@@ -18,6 +18,7 @@
 #include <uhd/usrp/tune_helper.hpp>
 #include <uhd/utils/algorithm.hpp>
 #include <uhd/usrp/subdev_props.hpp>
+#include <uhd/usrp/dsp_props.hpp>
 #include <cmath>
 
 using namespace uhd;
@@ -34,8 +35,8 @@ static tune_result_t tune_xx_subdev_and_dxc(
     wax::obj subdev_freq_proxy = subdev[SUBDEV_PROP_FREQ];
     bool subdev_quadrature = subdev[SUBDEV_PROP_QUADRATURE].as<bool>();
     bool subdev_spectrum_inverted = subdev[SUBDEV_PROP_SPECTRUM_INVERTED].as<bool>();
-    wax::obj dxc_freq_proxy = dxc[std::string("freq")];
-    double dxc_sample_rate = dxc[std::string("if_rate")].as<double>();
+    wax::obj dxc_freq_proxy = dxc[DSP_PROP_FREQ_SHIFT];
+    double dxc_sample_rate = dxc[DSP_PROP_CODEC_RATE].as<double>();
 
     // Ask the d'board to tune as closely as it can to target_freq+lo_offset
     double target_inter_freq = target_freq + lo_offset;
@@ -96,8 +97,8 @@ tune_result_t uhd::usrp::tune_rx_subdev_and_ddc(
 ){
     double lo_offset = 0.0;
     //if the local oscillator will be in the passband, use an offset
-    if (subdev[SUBDEV_PROP_LO_INTERFERES].as<bool>()){
-        lo_offset = 2.0*ddc[std::string("bb_rate")].as<double>();
+    if (subdev[SUBDEV_PROP_USE_LO_OFFSET].as<bool>()){
+        lo_offset = 2.0*ddc[DSP_PROP_HOST_RATE].as<double>();
     }
     return tune_rx_subdev_and_ddc(subdev, ddc, target_freq, lo_offset);
 }
@@ -119,8 +120,8 @@ tune_result_t uhd::usrp::tune_tx_subdev_and_duc(
 ){
     double lo_offset = 0.0;
     //if the local oscillator will be in the passband, use an offset
-    if (subdev[SUBDEV_PROP_LO_INTERFERES].as<bool>()){
-        lo_offset = 2.0*duc[std::string("bb_rate")].as<double>();
+    if (subdev[SUBDEV_PROP_USE_LO_OFFSET].as<bool>()){
+        lo_offset = 2.0*duc[DSP_PROP_HOST_RATE].as<double>();
     }
     return tune_tx_subdev_and_duc(subdev, duc, target_freq, lo_offset);
 }
diff --git a/host/lib/usrp/usrp2/dboard_impl.cpp b/host/lib/usrp/usrp2/dboard_impl.cpp
index 30883cd50..d1515f2d5 100644
--- a/host/lib/usrp/usrp2/dboard_impl.cpp
+++ b/host/lib/usrp/usrp2/dboard_impl.cpp
@@ -49,11 +49,11 @@ void usrp2_impl::dboard_init(void){
     );
 
     //load dboards
-    _rx_dboards[""] = wax_obj_proxy::make(
+    _rx_dboard_proxy = wax_obj_proxy::make(
         boost::bind(&usrp2_impl::rx_dboard_get, this, _1, _2),
         boost::bind(&usrp2_impl::rx_dboard_set, this, _1, _2)
     );
-    _tx_dboards[""] = wax_obj_proxy::make(
+    _tx_dboard_proxy = wax_obj_proxy::make(
         boost::bind(&usrp2_impl::tx_dboard_get, this, _1, _2),
         boost::bind(&usrp2_impl::tx_dboard_set, this, _1, _2)
     );
@@ -81,7 +81,7 @@ void usrp2_impl::update_rx_mux_config(void){
         rx_mux = (((rx_mux >> 0) & 0x3) << 2) | (((rx_mux >> 2) & 0x3) << 0);
     }
 
-    this->poke(FR_DSP_RX_MUX, rx_mux);
+    this->poke32(FR_DSP_RX_MUX, rx_mux);
 }
 
 void usrp2_impl::update_tx_mux_config(void){
@@ -94,7 +94,7 @@ void usrp2_impl::update_tx_mux_config(void){
         tx_mux = (((tx_mux >> 0) & 0x1) << 1) | (((tx_mux >> 1) & 0x1) << 0);
     }
 
-    this->poke(FR_DSP_TX_MUX, tx_mux);
+    this->poke32(FR_DSP_TX_MUX, tx_mux);
 }
 
 /***********************************************************************
diff --git a/host/lib/usrp/usrp2/dboard_interface.cpp b/host/lib/usrp/usrp2/dboard_interface.cpp
index 2e79381c5..6dd756420 100644
--- a/host/lib/usrp/usrp2/dboard_interface.cpp
+++ b/host/lib/usrp/usrp2/dboard_interface.cpp
@@ -48,17 +48,7 @@ private:
     );
 
     usrp2_impl *_impl;
-
-    //shadows
     boost::uint32_t _ddr_shadow;
-    uhd::dict<atr_reg_t, boost::uint32_t> _atr_reg_shadows;
-
-    //utilities
-    static int bank_to_shift(gpio_bank_t bank){
-        static const uhd::dict<gpio_bank_t, int> _bank_to_shift = \
-        boost::assign::map_list_of(GPIO_BANK_RX, 0)(GPIO_BANK_TX, 16);
-        return _bank_to_shift[bank];
-    }
 };
 
 /***********************************************************************
@@ -74,6 +64,14 @@ dboard_interface::sptr make_usrp2_dboard_interface(usrp2_impl *impl){
 usrp2_dboard_interface::usrp2_dboard_interface(usrp2_impl *impl){
     _impl = impl;
     _ddr_shadow = 0;
+
+    //set the selection mux to use atr
+    boost::uint32_t new_sels = 0x0;
+    for(size_t i = 0; i < 16; i++){
+        new_sels |= FRF_GPIO_SEL_ATR << (i*2);
+    }
+    _impl->poke32(FR_GPIO_TX_SEL, new_sels);
+    _impl->poke32(FR_GPIO_RX_SEL, new_sels);
 }
 
 usrp2_dboard_interface::~usrp2_dboard_interface(void){
@@ -94,43 +92,44 @@ double usrp2_dboard_interface::get_tx_clock_rate(void){
 /***********************************************************************
  * GPIO
  **********************************************************************/
+static int bank_to_shift(dboard_interface::gpio_bank_t bank){
+    switch(bank){
+    case dboard_interface::GPIO_BANK_RX: return 0;
+    case dboard_interface::GPIO_BANK_TX: return 16;
+    }
+    throw std::runtime_error("unknown gpio bank type");
+}
+
 void usrp2_dboard_interface::set_gpio_ddr(gpio_bank_t bank, boost::uint16_t value){
-    //calculate the new 32 bit ddr value
-    int shift = bank_to_shift(bank);
-    boost::uint32_t new_ddr_val =
-        (_ddr_shadow & ~(boost::uint32_t(0xffff) << shift)) //zero out new bits
-        | (boost::uint32_t(value) << shift); //or'ed in the new bits
-
-    //poke in the value and shadow
-    _impl->poke(FR_GPIO_DDR, new_ddr_val);
-    _ddr_shadow = new_ddr_val;
+    _ddr_shadow = \
+        (_ddr_shadow & ~(0xffff << bank_to_shift(bank))) |
+        (boost::uint32_t(value) << bank_to_shift(bank));
+    _impl->poke32(FR_GPIO_DDR, _ddr_shadow);
 }
 
 boost::uint16_t usrp2_dboard_interface::read_gpio(gpio_bank_t bank){
-    boost::uint32_t data = _impl->peek(FR_GPIO_IO);
-    return boost::uint16_t(data >> bank_to_shift(bank));
+    return boost::uint16_t(_impl->peek32(FR_GPIO_IO) >> bank_to_shift(bank));
 }
 
-void usrp2_dboard_interface::set_atr_reg(gpio_bank_t bank, atr_reg_t reg, boost::uint16_t value){
-    //map the atr reg to an offset in register space
-    static const uhd::dict<atr_reg_t, int> reg_to_addr = boost::assign::map_list_of
-        (ATR_REG_IDLE, FR_ATR_IDLE) (ATR_REG_TX_ONLY, FR_ATR_TX)
-        (ATR_REG_RX_ONLY, FR_ATR_RX) (ATR_REG_FULL_DUPLEX, FR_ATR_FULL)
+void usrp2_dboard_interface::set_atr_reg(gpio_bank_t bank, atr_reg_t atr, boost::uint16_t value){
+    //define mapping of bank to atr regs to register address
+    static const uhd::dict<
+        gpio_bank_t, uhd::dict<atr_reg_t, boost::uint32_t>
+    > bank_to_atr_to_addr = boost::assign::map_list_of
+        (GPIO_BANK_RX, boost::assign::map_list_of
+            (ATR_REG_IDLE,        FR_ATR_IDLE_RXSIDE)
+            (ATR_REG_TX_ONLY,     FR_ATR_INTX_RXSIDE)
+            (ATR_REG_RX_ONLY,     FR_ATR_INRX_RXSIDE)
+            (ATR_REG_FULL_DUPLEX, FR_ATR_FULL_RXSIDE)
+        )
+        (GPIO_BANK_TX, boost::assign::map_list_of
+            (ATR_REG_IDLE,        FR_ATR_IDLE_TXSIDE)
+            (ATR_REG_TX_ONLY,     FR_ATR_INTX_TXSIDE)
+            (ATR_REG_RX_ONLY,     FR_ATR_INRX_TXSIDE)
+            (ATR_REG_FULL_DUPLEX, FR_ATR_FULL_TXSIDE)
+        )
     ;
-    ASSERT_THROW(reg_to_addr.has_key(reg));
-
-    //ensure a value exists in the shadow
-    if (not _atr_reg_shadows.has_key(reg)) _atr_reg_shadows[reg] = 0;
-
-    //calculate the new 32 bit atr value
-    int shift = bank_to_shift(bank);
-    boost::uint32_t new_atr_val =
-        (_atr_reg_shadows[reg] & ~(boost::uint32_t(0xffff) << shift)) //zero out new bits
-        | (boost::uint32_t(value) << shift); //or'ed in the new bits
-
-    //poke in the value and shadow
-    _impl->poke(reg_to_addr[reg], new_atr_val);
-    _atr_reg_shadows[reg] = new_atr_val;
+    _impl->poke16(bank_to_atr_to_addr[bank][atr], value);
 }
 
 /***********************************************************************
diff --git a/host/lib/usrp/usrp2/dsp_impl.cpp b/host/lib/usrp/usrp2/dsp_impl.cpp
index d70248682..92b55d029 100644
--- a/host/lib/usrp/usrp2/dsp_impl.cpp
+++ b/host/lib/usrp/usrp2/dsp_impl.cpp
@@ -54,9 +54,19 @@ static boost::uint32_t calculate_iq_scale_word(boost::int16_t i, boost::int16_t
     return (boost::uint16_t(i) << 16) | (boost::uint16_t(q) << 0);
 }
 
+template <class rate_t> static rate_t
+pick_closest_rate(double exact_rate, const std::vector<rate_t> &rates){
+    rate_t closest_match = rates.at(0);
+    BOOST_FOREACH(rate_t possible_rate, rates){
+        if(std::abs(exact_rate - possible_rate) < std::abs(exact_rate - closest_match))
+            closest_match = possible_rate;
+    }
+    return closest_match;
+}
+
 void usrp2_impl::init_ddc_config(void){
     //create the ddc in the rx dsp dict
-    _rx_dsps["ddc0"] = wax_obj_proxy::make(
+    _rx_dsp_proxy = wax_obj_proxy::make(
         boost::bind(&usrp2_impl::ddc_get, this, _1, _2),
         boost::bind(&usrp2_impl::ddc_set, this, _1, _2)
     );
@@ -67,124 +77,71 @@ void usrp2_impl::init_ddc_config(void){
     update_ddc_config();
 
     //initial command that kills streaming (in case if was left on)
-    stream_cmd_t stream_cmd_off;
-    stream_cmd_off.stream_now = true;
-    stream_cmd_off.continuous = false;
-    stream_cmd_off.num_samps = 0;
-    issue_ddc_stream_cmd(stream_cmd_off);
+    issue_ddc_stream_cmd(stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
 }
 
 void usrp2_impl::update_ddc_config(void){
     //set the decimation
-    this->poke(FR_DSP_RX_DECIM_RATE, _ddc_decim);
+    this->poke32(FR_DSP_RX_DECIM_RATE, _ddc_decim);
 
     //set the scaling
     static const boost::int16_t default_rx_scale_iq = 1024;
-    this->poke(FR_DSP_RX_SCALE_IQ,
+    this->poke32(FR_DSP_RX_SCALE_IQ,
         calculate_iq_scale_word(default_rx_scale_iq, default_rx_scale_iq)
     );
 }
 
-void usrp2_impl::issue_ddc_stream_cmd(const stream_cmd_t &stream_cmd){
-    //setup the out data
-    usrp2_ctrl_data_t out_data;
-    out_data.id = htonl(USRP2_CTRL_ID_SEND_STREAM_COMMAND_FOR_ME_BRO);
-    out_data.data.stream_cmd.now = (stream_cmd.stream_now)? 1 : 0;
-    out_data.data.stream_cmd.continuous = (stream_cmd.continuous)? 1 : 0;
-    out_data.data.stream_cmd.secs = htonl(stream_cmd.time_spec.secs);
-    out_data.data.stream_cmd.ticks = htonl(stream_cmd.time_spec.ticks);
-    out_data.data.stream_cmd.num_samps = htonl(stream_cmd.num_samps);
-
-    //send and recv
-    usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
-    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THAT_STREAM_COMMAND_DUDE);
-}
-
 /***********************************************************************
  * DDC Properties
  **********************************************************************/
 void usrp2_impl::ddc_get(const wax::obj &key, wax::obj &val){
-    //handle the case where the key is an expected dsp property
-    if (key.type() == typeid(dsp_prop_t)){
-        switch(key.as<dsp_prop_t>()){
-        case DSP_PROP_NAME:
-            val = std::string("usrp2 ddc0");
-            return;
-
-        case DSP_PROP_OTHERS:{
-                prop_names_t others = boost::assign::list_of
-                    ("if_rate")
-                    ("bb_rate")
-                    ("decim")
-                    ("decims")
-                    ("freq")
-                    ("stream_cmd")
-                ;
-                val = others;
-            }
-            return;
-        }
-    }
-
-    //handle string-based properties specific to this dsp
-    std::string key_name = key.as<std::string>();
-    if (key_name == "if_rate"){
-        val = get_master_clock_freq();
+    switch(key.as<dsp_prop_t>()){
+    case DSP_PROP_NAME:
+        val = std::string("usrp2 ddc0");
         return;
-    }
-    else if (key_name == "bb_rate"){
-        val = get_master_clock_freq()/_ddc_decim;
+
+    case DSP_PROP_OTHERS:
+        val = prop_names_t(); //empty
         return;
-    }
-    else if (key_name == "decim"){
-        val = _ddc_decim;
+
+    case DSP_PROP_FREQ_SHIFT:
+        val = _ddc_freq;
         return;
-    }
-    else if (key_name == "decims"){
-        val = _allowed_decim_and_interp_rates;
+
+    case DSP_PROP_CODEC_RATE:
+        val = get_master_clock_freq();
         return;
-    }
-    else if (key_name == "freq"){
-        val = _ddc_freq;
+
+    case DSP_PROP_HOST_RATE:
+        val = get_master_clock_freq()/_ddc_decim;
         return;
     }
-
-    throw std::invalid_argument(str(
-        boost::format("error getting: unknown key with name %s") % key_name
-    ));
 }
 
 void usrp2_impl::ddc_set(const wax::obj &key, const wax::obj &val){
-    //handle string-based properties specific to this dsp
-    std::string key_name = key.as<std::string>();
-    if (key_name == "decim"){
-        size_t new_decim = val.as<size_t>();
-        assert_has(
-            _allowed_decim_and_interp_rates,
-            new_decim, "usrp2 decimation"
-        );
-        _ddc_decim = new_decim; //shadow
-        update_ddc_config();
-        return;
-    }
-    else if (key_name == "freq"){
-        double new_freq = val.as<double>();
-        ASSERT_THROW(new_freq <= get_master_clock_freq()/2.0);
-        ASSERT_THROW(new_freq >= -get_master_clock_freq()/2.0);
-        _ddc_freq = new_freq; //shadow
-        this->poke(FR_DSP_RX_FREQ,
-            calculate_freq_word_and_update_actual_freq(_ddc_freq, get_master_clock_freq())
-        );
+    switch(key.as<dsp_prop_t>()){
+
+    case DSP_PROP_FREQ_SHIFT:{
+            double new_freq = val.as<double>();
+            ASSERT_THROW(new_freq <= get_master_clock_freq()/2.0);
+            ASSERT_THROW(new_freq >= -get_master_clock_freq()/2.0);
+            _ddc_freq = new_freq; //shadow
+            this->poke32(FR_DSP_RX_FREQ,
+                calculate_freq_word_and_update_actual_freq(_ddc_freq, get_master_clock_freq())
+            );
+        }
         return;
-    }
-    else if (key_name == "stream_cmd"){
-        issue_ddc_stream_cmd(val.as<stream_cmd_t>());
+
+    case DSP_PROP_HOST_RATE:{
+            double extact_rate = get_master_clock_freq()/val.as<double>();
+            _ddc_decim = pick_closest_rate(extact_rate, _allowed_decim_and_interp_rates);
+            update_ddc_config();
+        }
         return;
-    }
 
-    throw std::invalid_argument(str(
-        boost::format("error setting: unknown key with name %s") % key_name
-    ));
+    default:
+        throw std::runtime_error("Error: trying to set read-only property on usrp2 ddc0");
+    }
 }
 
 /***********************************************************************
@@ -192,7 +149,7 @@ void usrp2_impl::ddc_set(const wax::obj &key, const wax::obj &val){
  **********************************************************************/
 void usrp2_impl::init_duc_config(void){
     //create the duc in the tx dsp dict
-    _tx_dsps["duc0"] = wax_obj_proxy::make(
+    _tx_dsp_proxy = wax_obj_proxy::make(
         boost::bind(&usrp2_impl::duc_get, this, _1, _2),
         boost::bind(&usrp2_impl::duc_set, this, _1, _2)
     );
@@ -213,90 +170,61 @@ void usrp2_impl::update_duc_config(void){
     boost::int16_t scale = rint((4096*std::pow(2, ceil(log2(interp_cubed))))/(1.65*interp_cubed));
 
     //set the interpolation
-    this->poke(FR_DSP_TX_INTERP_RATE, _ddc_decim);
+    this->poke32(FR_DSP_TX_INTERP_RATE, _ddc_decim);
 
     //set the scaling
-    this->poke(FR_DSP_TX_SCALE_IQ, calculate_iq_scale_word(scale, scale));
+    this->poke32(FR_DSP_TX_SCALE_IQ, calculate_iq_scale_word(scale, scale));
 }
 
 /***********************************************************************
  * DUC Properties
  **********************************************************************/
 void usrp2_impl::duc_get(const wax::obj &key, wax::obj &val){
-    //handle the case where the key is an expected dsp property
-    if (key.type() == typeid(dsp_prop_t)){
-        switch(key.as<dsp_prop_t>()){
-        case DSP_PROP_NAME:
-            val = std::string("usrp2 duc0");
-            return;
-
-        case DSP_PROP_OTHERS:{
-                prop_names_t others = boost::assign::list_of
-                    ("if_rate")
-                    ("bb_rate")
-                    ("interp")
-                    ("interps")
-                    ("freq")
-                ;
-                val = others;
-            }
-            return;
-        }
-    }
-
-    //handle string-based properties specific to this dsp
-    std::string key_name = key.as<std::string>();
-    if (key_name == "if_rate"){
-        val = get_master_clock_freq();
+    switch(key.as<dsp_prop_t>()){
+    case DSP_PROP_NAME:
+        val = std::string("usrp2 duc0");
         return;
-    }
-    else if (key_name == "bb_rate"){
-        val = get_master_clock_freq()/_duc_interp;
+
+    case DSP_PROP_OTHERS:
+        val = prop_names_t(); //empty
         return;
-    }
-    else if (key_name == "interp"){
-        val = _duc_interp;
+
+    case DSP_PROP_FREQ_SHIFT:
+        val = _duc_freq;
         return;
-    }
-    else if (key_name == "interps"){
-        val = _allowed_decim_and_interp_rates;
+
+    case DSP_PROP_CODEC_RATE:
+        val = get_master_clock_freq();
         return;
-    }
-    else if (key_name == "freq"){
-        val = _duc_freq;
+
+    case DSP_PROP_HOST_RATE:
+        val = get_master_clock_freq()/_duc_interp;
         return;
     }
-
-    throw std::invalid_argument(str(
-        boost::format("error getting: unknown key with name %s") % key_name
-    ));
 }
 
 void usrp2_impl::duc_set(const wax::obj &key, const wax::obj &val){
-    //handle string-based properties specific to this dsp
-    std::string key_name = key.as<std::string>();
-    if (key_name == "interp"){
-        size_t new_interp = val.as<size_t>();
-        assert_has(
-            _allowed_decim_and_interp_rates,
-            new_interp, "usrp2 interpolation"
-        );
-        _duc_interp = new_interp; //shadow
-        update_duc_config();
+    switch(key.as<dsp_prop_t>()){
+
+    case DSP_PROP_FREQ_SHIFT:{
+            double new_freq = val.as<double>();
+            ASSERT_THROW(new_freq <= get_master_clock_freq()/2.0);
+            ASSERT_THROW(new_freq >= -get_master_clock_freq()/2.0);
+            _duc_freq = new_freq; //shadow
+            this->poke32(FR_DSP_TX_FREQ,
+                calculate_freq_word_and_update_actual_freq(_duc_freq, get_master_clock_freq())
+            );
+        }
         return;
-    }
-    else if (key_name == "freq"){
-        double new_freq = val.as<double>();
-        ASSERT_THROW(new_freq <= get_master_clock_freq()/2.0);
-        ASSERT_THROW(new_freq >= -get_master_clock_freq()/2.0);
-        _duc_freq = new_freq; //shadow
-        this->poke(FR_DSP_TX_FREQ,
-            calculate_freq_word_and_update_actual_freq(_duc_freq, get_master_clock_freq())
-        );
+
+    case DSP_PROP_HOST_RATE:{
+            double extact_rate = get_master_clock_freq()/val.as<double>();
+            _duc_interp = pick_closest_rate(extact_rate, _allowed_decim_and_interp_rates);
+            update_duc_config();
+        }
         return;
-    }
 
-    throw std::invalid_argument(str(
-        boost::format("error setting: unknown key with name %s") % key_name
-    ));
+    default:
+        throw std::runtime_error("Error: trying to set read-only property on usrp2 duc0");
+    }
 }
diff --git a/host/lib/usrp/usrp2/fw_common.h b/host/lib/usrp/usrp2/fw_common.h
index c168614ee..019f3b931 100644
--- a/host/lib/usrp/usrp2/fw_common.h
+++ b/host/lib/usrp/usrp2/fw_common.h
@@ -129,7 +129,8 @@ typedef struct{
         struct {
             _SINS_ uint8_t now; //stream now?
             _SINS_ uint8_t continuous; //auto-reload commmands?
-            _SINS_ uint8_t _pad[2];
+            _SINS_ uint8_t chain;
+            _SINS_ uint8_t _pad[1];
             _SINS_ uint32_t secs;
             _SINS_ uint32_t ticks;
             _SINS_ uint32_t num_samps;
@@ -137,6 +138,7 @@ typedef struct{
         struct {
             _SINS_ uint32_t addr;
             _SINS_ uint32_t data;
+            _SINS_ uint8_t num_bytes; //1, 2, 4
         } poke_args;
     } data;
 } usrp2_ctrl_data_t;
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
index c87884ebb..a58e32619 100644
--- a/host/lib/usrp/usrp2/io_impl.cpp
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -171,15 +171,21 @@ void usrp2_impl::recv_raw(rx_metadata_t &metadata){
  **********************************************************************/
 size_t usrp2_impl::send(
     const asio::const_buffer &buff,
-    const tx_metadata_t &metadata,
+    const tx_metadata_t &metadata_,
     const io_type_t &io_type
 ){
+    tx_metadata_t metadata = metadata_; //rw copy to change later
+
     boost::uint32_t tx_mem[_mtu/sizeof(boost::uint32_t)];
     size_t num_samps = std::min(
         asio::buffer_size(buff)/io_type.size,
         size_t(_max_tx_samples_per_packet)
     );
 
+    //kill the end of burst flag if this is a fragment
+    if (asio::buffer_size(buff)/io_type.size < num_samps)
+        metadata.end_of_burst = false;
+
     size_t num_header_words32, num_packet_words32;
     size_t packet_count = _tx_stream_id_to_packet_seq[metadata.stream_id]++;
 
@@ -222,12 +228,12 @@ size_t usrp2_impl::recv(
 ){
     //perform a receive if no rx data is waiting to be copied
     if (asio::buffer_size(_rx_copy_buff) == 0){
+        _fragment_offset_in_samps = 0;
         recv_raw(metadata);
     }
     //otherwise flag the metadata to show that is is a fragment
     else{
         metadata = rx_metadata_t();
-        metadata.is_fragment = true;
     }
 
     //extract the number of samples available to copy
@@ -240,6 +246,11 @@ size_t usrp2_impl::recv(
     );
     const boost::uint32_t *items = asio::buffer_cast<const boost::uint32_t*>(_rx_copy_buff);
 
+    //setup the fragment flags and offset
+    metadata.more_fragments = asio::buffer_size(buff)/io_type.size < num_samps;
+    metadata.fragment_offset = _fragment_offset_in_samps;
+    _fragment_offset_in_samps += num_samps; //set for next time
+
     //copy the samples from the recv buffer
     switch(io_type.tid){
     case io_type_t::COMPLEX_FLOAT32:
diff --git a/host/lib/usrp/usrp2/mboard_impl.cpp b/host/lib/usrp/usrp2/mboard_impl.cpp
index 7594c85fa..94ab88a6b 100644
--- a/host/lib/usrp/usrp2/mboard_impl.cpp
+++ b/host/lib/usrp/usrp2/mboard_impl.cpp
@@ -29,7 +29,7 @@ using namespace uhd::usrp;
  * Helper Methods
  **********************************************************************/
 void usrp2_impl::mboard_init(void){
-    _mboards[""] = wax_obj_proxy::make(
+    _mboard_proxy = wax_obj_proxy::make(
         boost::bind(&usrp2_impl::mboard_get, this, _1, _2),
         boost::bind(&usrp2_impl::mboard_set, this, _1, _2)
     );
@@ -67,19 +67,56 @@ void usrp2_impl::update_clock_config(void){
     }
 
     //set the pps flags
-    this->poke(FR_TIME64_FLAGS, pps_flags);
+    this->poke32(FR_TIME64_FLAGS, pps_flags);
 
     //TODO clock source ref 10mhz (spi ad9510)
 }
 
 void usrp2_impl::set_time_spec(const time_spec_t &time_spec, bool now){
     //set ticks and seconds
-    this->poke(FR_TIME64_SECS, time_spec.secs);
-    this->poke(FR_TIME64_TICKS, time_spec.ticks);
+    this->poke32(FR_TIME64_SECS, time_spec.secs);
+    this->poke32(FR_TIME64_TICKS, time_spec.ticks);
 
     //set the register to latch it all in
     boost::uint32_t imm_flags = (now)? FRF_TIME64_LATCH_NOW : FRF_TIME64_LATCH_NEXT_PPS;
-    this->poke(FR_TIME64_IMM, imm_flags);
+    this->poke32(FR_TIME64_IMM, imm_flags);
+}
+
+void usrp2_impl::issue_ddc_stream_cmd(const stream_cmd_t &stream_cmd){
+    //setup the out data
+    usrp2_ctrl_data_t out_data;
+    out_data.id = htonl(USRP2_CTRL_ID_SEND_STREAM_COMMAND_FOR_ME_BRO);
+    out_data.data.stream_cmd.now = (stream_cmd.stream_now)? 1 : 0;
+    out_data.data.stream_cmd.secs = htonl(stream_cmd.time_spec.secs);
+    out_data.data.stream_cmd.ticks = htonl(stream_cmd.time_spec.ticks);
+
+    //set these to defaults, then change in the switch statement
+    out_data.data.stream_cmd.continuous = 0;
+    out_data.data.stream_cmd.chain = 0;
+    out_data.data.stream_cmd.num_samps = htonl(stream_cmd.num_samps);
+
+    //setup chain, num samps, and continuous below
+    switch(stream_cmd.stream_mode){
+    case stream_cmd_t::STREAM_MODE_START_CONTINUOUS:
+        out_data.data.stream_cmd.continuous = 1;
+        break;
+
+    case stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS:
+        out_data.data.stream_cmd.num_samps = htonl(0);
+        break;
+
+    case stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE:
+        //all set by defaults above
+        break;
+
+    case stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_MORE:
+        out_data.data.stream_cmd.chain = 1;
+        break;
+    }
+
+    //send and recv
+    usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
+    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THAT_STREAM_COMMAND_DUDE);
 }
 
 /***********************************************************************
@@ -136,21 +173,21 @@ void usrp2_impl::mboard_get(const wax::obj &key_, wax::obj &val){
         return;
 
     case MBOARD_PROP_RX_DBOARD:
-        ASSERT_THROW(_rx_dboards.has_key(name));
-        val = _rx_dboards[name]->get_link();
+        ASSERT_THROW(name == "");
+        val = _rx_dboard_proxy->get_link();
         return;
 
     case MBOARD_PROP_RX_DBOARD_NAMES:
-        val = prop_names_t(_rx_dboards.get_keys());
+        val = prop_names_t(1, "");
         return;
 
     case MBOARD_PROP_TX_DBOARD:
-        ASSERT_THROW(_tx_dboards.has_key(name));
-        val = _tx_dboards[name]->get_link();
+        ASSERT_THROW(name == "");
+        val = _tx_dboard_proxy->get_link();
         return;
 
     case MBOARD_PROP_TX_DBOARD_NAMES:
-        val = prop_names_t(_tx_dboards.get_keys());
+        val = prop_names_t(1, "");
         return;
 
     case MBOARD_PROP_CLOCK_RATE:
@@ -158,29 +195,28 @@ void usrp2_impl::mboard_get(const wax::obj &key_, wax::obj &val){
         return;
 
     case MBOARD_PROP_RX_DSP:
-        ASSERT_THROW(_rx_dsps.has_key(name));
-        val = _rx_dsps[name]->get_link();
+        ASSERT_THROW(name == "");
+        val = _rx_dsp_proxy->get_link();
         return;
 
     case MBOARD_PROP_RX_DSP_NAMES:
-        val = prop_names_t(_rx_dsps.get_keys());
+        val = prop_names_t(1, "");
         return;
 
     case MBOARD_PROP_TX_DSP:
-        ASSERT_THROW(_tx_dsps.has_key(name));
-        val = _tx_dsps[name]->get_link();
+        ASSERT_THROW(name == "");
+        val = _tx_dsp_proxy->get_link();
         return;
 
     case MBOARD_PROP_TX_DSP_NAMES:
-        val = prop_names_t(_tx_dsps.get_keys());
+        val = prop_names_t(1, "");
         return;
 
     case MBOARD_PROP_CLOCK_CONFIG:
         val = _clock_config;
         return;
 
-    case MBOARD_PROP_TIME_NOW:
-    case MBOARD_PROP_TIME_NEXT_PPS:
+    default:
         throw std::runtime_error("Error: trying to get write-only property on usrp2 mboard");
 
     }
@@ -226,27 +262,19 @@ void usrp2_impl::mboard_set(const wax::obj &key, const wax::obj &val){
         update_clock_config();
         return;
 
-    case MBOARD_PROP_TIME_NOW:{
+    case MBOARD_PROP_TIME_NOW:
         set_time_spec(val.as<time_spec_t>(), true);
         return;
-    }
 
-    case MBOARD_PROP_TIME_NEXT_PPS:{
+    case MBOARD_PROP_TIME_NEXT_PPS:
         set_time_spec(val.as<time_spec_t>(), false);
         return;
-    }
 
-    case MBOARD_PROP_NAME:
-    case MBOARD_PROP_OTHERS:
-    case MBOARD_PROP_CLOCK_RATE:
-    case MBOARD_PROP_RX_DSP:
-    case MBOARD_PROP_RX_DSP_NAMES:
-    case MBOARD_PROP_TX_DSP:
-    case MBOARD_PROP_TX_DSP_NAMES:
-    case MBOARD_PROP_RX_DBOARD:
-    case MBOARD_PROP_RX_DBOARD_NAMES:
-    case MBOARD_PROP_TX_DBOARD:
-    case MBOARD_PROP_TX_DBOARD_NAMES:
+    case MBOARD_PROP_STREAM_CMD:
+        issue_ddc_stream_cmd(val.as<stream_cmd_t>());
+        return;
+
+    default:
         throw std::runtime_error("Error: trying to set read-only property on usrp2 mboard");
 
     }
diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp
index b3a22e175..a7be2da8c 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -174,28 +174,47 @@ double usrp2_impl::get_master_clock_freq(void){
     return 100e6;
 }
 
-void usrp2_impl::poke(boost::uint32_t addr, boost::uint32_t data){
+template <class T> void impl_poke(usrp2_impl *impl, boost::uint32_t addr, T data){
     //setup the out data
     usrp2_ctrl_data_t out_data;
     out_data.id = htonl(USRP2_CTRL_ID_POKE_THIS_REGISTER_FOR_ME_BRO);
     out_data.data.poke_args.addr = htonl(addr);
-    out_data.data.poke_args.data = htonl(data);
+    out_data.data.poke_args.data = htonl(boost::uint32_t(data));
+    out_data.data.poke_args.num_bytes = sizeof(T);
 
     //send and recv
-    usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data);
+    usrp2_ctrl_data_t in_data = impl->ctrl_send_and_recv(out_data);
     ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_OMG_POKED_REGISTER_SO_BAD_DUDE);
 }
 
-boost::uint32_t usrp2_impl::peek(boost::uint32_t addr){
+template <class T> T impl_peek(usrp2_impl *impl, boost::uint32_t addr){
     //setup the out data
     usrp2_ctrl_data_t out_data;
     out_data.id = htonl(USRP2_CTRL_ID_PEEK_AT_THIS_REGISTER_FOR_ME_BRO);
     out_data.data.poke_args.addr = htonl(addr);
+    out_data.data.poke_args.num_bytes = sizeof(T);
 
     //send and recv
-    usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data);
+    usrp2_ctrl_data_t in_data = impl->ctrl_send_and_recv(out_data);
     ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_WOAH_I_DEFINITELY_PEEKED_IT_DUDE);
-    return ntohl(out_data.data.poke_args.data);
+    return T(ntohl(out_data.data.poke_args.data));
+}
+
+
+void usrp2_impl::poke32(boost::uint32_t addr, boost::uint32_t data){
+    return impl_poke<boost::uint32_t>(this, addr, data);
+}
+
+boost::uint32_t usrp2_impl::peek32(boost::uint32_t addr){
+    return impl_peek<boost::uint32_t>(this, addr);
+}
+
+void usrp2_impl::poke16(boost::uint32_t addr, boost::uint16_t data){
+    return impl_poke<boost::uint16_t>(this, addr, data);
+}
+
+boost::uint16_t usrp2_impl::peek16(boost::uint32_t addr){
+    return impl_peek<boost::uint16_t>(this, addr);
 }
 
 /***********************************************************************
@@ -236,12 +255,12 @@ void usrp2_impl::get(const wax::obj &key_, wax::obj &val){
         return;
 
     case DEVICE_PROP_MBOARD:
-        ASSERT_THROW(_mboards.has_key(name));
-        val = _mboards[name]->get_link();
+        ASSERT_THROW(name == "");
+        val = _mboard_proxy->get_link();
         return;
 
     case DEVICE_PROP_MBOARD_NAMES:
-        val = prop_names_t(_mboards.get_keys());
+        val = prop_names_t(1, "");
         return;
 
     case DEVICE_PROP_MAX_RX_SAMPLES:
diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp
index 55be420cd..baa6530b8 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.hpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.hpp
@@ -103,8 +103,11 @@ public:
     usrp2_ctrl_data_t ctrl_send_and_recv(const usrp2_ctrl_data_t &);
 
     //peek and poke registers
-    void poke(boost::uint32_t addr, boost::uint32_t data);
-    boost::uint32_t peek(boost::uint32_t addr);
+    void poke32(boost::uint32_t addr, boost::uint32_t data);
+    boost::uint32_t peek32(boost::uint32_t addr);
+
+    void poke16(boost::uint32_t addr, boost::uint16_t data);
+    boost::uint16_t peek16(boost::uint32_t addr);
 
     //misc access methods
     double get_master_clock_freq(void);
@@ -135,6 +138,7 @@ private:
     ;
     uhd::transport::smart_buffer::sptr _rx_smart_buff;
     boost::asio::const_buffer _rx_copy_buff;
+    size_t _fragment_offset_in_samps;
     void io_init(void);
 
     //udp transports for control and data
@@ -159,18 +163,18 @@ private:
     void mboard_init(void);
     void mboard_get(const wax::obj &, wax::obj &);
     void mboard_set(const wax::obj &, const wax::obj &);
-    uhd::dict<std::string, wax_obj_proxy::sptr> _mboards;
+    wax_obj_proxy::sptr _mboard_proxy;
 
     //properties interface for rx dboard
     void rx_dboard_get(const wax::obj &, wax::obj &);
     void rx_dboard_set(const wax::obj &, const wax::obj &);
-    uhd::dict<std::string, wax_obj_proxy::sptr> _rx_dboards;
+    wax_obj_proxy::sptr _rx_dboard_proxy;
     uhd::prop_names_t _rx_subdevs_in_use;
 
     //properties interface for tx dboard
     void tx_dboard_get(const wax::obj &, wax::obj &);
     void tx_dboard_set(const wax::obj &, const wax::obj &);
-    uhd::dict<std::string, wax_obj_proxy::sptr> _tx_dboards;
+    wax_obj_proxy::sptr _tx_dboard_proxy;
     uhd::prop_names_t _tx_subdevs_in_use;
     void update_rx_mux_config(void);
     void update_tx_mux_config(void);
@@ -192,12 +196,12 @@ private:
     //properties interface for ddc
     void ddc_get(const wax::obj &, wax::obj &);
     void ddc_set(const wax::obj &, const wax::obj &);
-    uhd::dict<std::string, wax_obj_proxy::sptr> _rx_dsps;
+    wax_obj_proxy::sptr _rx_dsp_proxy;
 
     //properties interface for duc
     void duc_get(const wax::obj &, wax::obj &);
     void duc_set(const wax::obj &, const wax::obj &);
-    uhd::dict<std::string, wax_obj_proxy::sptr> _tx_dsps;
+    wax_obj_proxy::sptr _tx_dsp_proxy;
 
 };
 
diff --git a/host/lib/usrp/usrp2/usrp2_regs.hpp b/host/lib/usrp/usrp2/usrp2_regs.hpp
index 10545d712..77d9f4ad9 100644
--- a/host/lib/usrp/usrp2/usrp2_regs.hpp
+++ b/host/lib/usrp/usrp2/usrp2_regs.hpp
@@ -175,11 +175,12 @@
 //
 // These go to the daughterboard i/o pins
 //
-#define _FR_GPIO_ADDR(off) (0xC800 + (off) * sizeof(boost::uint32_t))
-#define FR_GPIO_IO     _FR_GPIO_ADDR(0)       // tx data in high 16, rx in low 16
-#define FR_GPIO_DDR    _FR_GPIO_ADDR(1)       // 32 bits, 1 means output. tx in high 16, rx in low 16
-#define FR_GPIO_TX_SEL _FR_GPIO_ADDR(2)       // 16 2-bit fields select which source goes to TX DB
-#define FR_GPIO_RX_SEL _FR_GPIO_ADDR(3)       // 16 2-bit fields select which source goes to RX DB
+#define FR_GPIO_BASE 0xC800
+
+#define FR_GPIO_IO         FR_GPIO_BASE + 0  // 32 bits, gpio io pins (tx high 16 bits, rx low 16 bits)
+#define FR_GPIO_DDR        FR_GPIO_BASE + 4  // 32 bits, gpio ddr, 1 means output (tx high 16 bits, rx low 16 bits)
+#define FR_GPIO_TX_SEL     FR_GPIO_BASE + 8  // 16 2-bit fields select which source goes to TX DB
+#define FR_GPIO_RX_SEL     FR_GPIO_BASE + 12 // 16 2-bit fields select which source goes to RX DB
 
 // each 2-bit sel field is layed out this way
 #define FRF_GPIO_SEL_SW        0 // if pin is an output, set by software in the io reg
@@ -190,10 +191,15 @@
 ///////////////////////////////////////////////////
 // ATR Controller, Slave 11
 ////////////////////////////////////////////////
-#define _FR_ATR_ADDR(off) (0xE400 + (off) * sizeof(boost::uint32_t))
-#define FR_ATR_IDLE    _FR_ATR_ADDR(0) // tx data in high 16, rx in low 16
-#define FR_ATR_TX      _FR_ATR_ADDR(1)
-#define FR_ATR_RX      _FR_ATR_ADDR(2)
-#define FR_ATR_FULL    _FR_ATR_ADDR(3)
+#define FR_ATR_BASE  0xE400
+
+#define FR_ATR_IDLE_TXSIDE  FR_ATR_BASE + 0
+#define FR_ATR_IDLE_RXSIDE  FR_ATR_BASE + 2
+#define FR_ATR_INTX_TXSIDE  FR_ATR_BASE + 4
+#define FR_ATR_INTX_RXSIDE  FR_ATR_BASE + 6
+#define FR_ATR_INRX_TXSIDE  FR_ATR_BASE + 8
+#define FR_ATR_INRX_RXSIDE  FR_ATR_BASE + 10
+#define FR_ATR_FULL_TXSIDE  FR_ATR_BASE + 12
+#define FR_ATR_FULL_RXSIDE  FR_ATR_BASE + 14
 
 #endif /* INCLUDED_USRP2_REGS_HPP */