usrp-e: merged master, does not build

32 files changed, 1533 insertions, 458 deletions

diff --git a/host/lib/usrp/CMakeLists.txt b/host/lib/usrp/CMakeLists.txt
index 814affdd0..4a45c263e 100644
--- a/host/lib/usrp/CMakeLists.txt
+++ b/host/lib/usrp/CMakeLists.txt
@@ -24,6 +24,13 @@ LIBUHD_APPEND_SOURCES(
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard_manager.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/dsp_utils.hpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/mimo_usrp.cpp
+    ${CMAKE_SOURCE_DIR}/lib/usrp/misc_utils.cpp
+    ${CMAKE_SOURCE_DIR}/lib/usrp/misc_utils.hpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/simple_usrp.cpp
+    ${CMAKE_SOURCE_DIR}/lib/usrp/subdev_spec.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/tune_helper.cpp
 )
+
+INCLUDE(${CMAKE_SOURCE_DIR}/lib/usrp/dboard/CMakeLists.txt)
+INCLUDE(${CMAKE_SOURCE_DIR}/lib/usrp/usrp2/CMakeLists.txt)
+INCLUDE(${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e/CMakeLists.txt)
diff --git a/host/lib/usrp/dboard/CMakeLists.txt b/host/lib/usrp/dboard/CMakeLists.txt
index 6093583d3..3e995009e 100644
--- a/host/lib/usrp/dboard/CMakeLists.txt
+++ b/host/lib/usrp/dboard/CMakeLists.txt
@@ -22,6 +22,7 @@ LIBUHD_APPEND_SOURCES(
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard/db_rfx.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard/db_xcvr2450.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard/db_wbx.cpp
+    ${CMAKE_SOURCE_DIR}/lib/usrp/dboard/db_dbsrx.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard/db_unknown.cpp
 )
 
diff --git a/host/lib/usrp/dboard/db_basic_and_lf.cpp b/host/lib/usrp/dboard/db_basic_and_lf.cpp
index 766deac78..9180828d8 100644
--- a/host/lib/usrp/dboard/db_basic_and_lf.cpp
+++ b/host/lib/usrp/dboard/db_basic_and_lf.cpp
@@ -16,6 +16,7 @@
 //
 
 #include <uhd/usrp/subdev_props.hpp>
+#include <uhd/types/dict.hpp>
 #include <uhd/types/ranges.hpp>
 #include <uhd/utils/assert.hpp>
 #include <uhd/utils/static.hpp>
@@ -138,17 +139,14 @@ void basic_rx::rx_get(const wax::obj &key_, wax::obj &val){
         val = prop_names_t(1, ""); //vector of 1 empty string
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = (get_subdev_name() == "AB"); //only quadrature in ab mode
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
-        return;
+    case SUBDEV_PROP_CONNECTION:{
+            static const uhd::dict<std::string, subdev_conn_t> name_to_conn = map_list_of
+                ("A",  SUBDEV_CONN_REAL_I)
+                ("B",  SUBDEV_CONN_REAL_Q)
+                ("AB", SUBDEV_CONN_COMPLEX_IQ)
+            ;
+            val = name_to_conn[get_subdev_name()];
+        } return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
         val = false;
@@ -237,16 +235,8 @@ void basic_tx::tx_get(const wax::obj &key_, wax::obj &val){
         val = prop_names_t(1, ""); //vector of 1 empty string
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_IQ;
         return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
diff --git a/host/lib/usrp/dboard/db_dbsrx.cpp b/host/lib/usrp/dboard/db_dbsrx.cpp
new file mode 100644
index 000000000..03e6b6255
--- /dev/null
+++ b/host/lib/usrp/dboard/db_dbsrx.cpp
@@ -0,0 +1,610 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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, see <http://www.gnu.org/licenses/>.
+//
+
+// No RX IO Pins Used
+
+// RX IO Functions
+
+#include "max2118_regs.hpp"
+#include <uhd/utils/static.hpp>
+#include <uhd/utils/assert.hpp>
+#include <uhd/utils/algorithm.hpp>
+#include <uhd/utils/warning.hpp>
+#include <uhd/types/ranges.hpp>
+#include <uhd/types/dict.hpp>
+#include <uhd/usrp/subdev_props.hpp>
+#include <uhd/usrp/dboard_base.hpp>
+#include <uhd/usrp/dboard_manager.hpp>
+#include <boost/assign/list_of.hpp>
+#include <boost/format.hpp>
+#include <boost/thread.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <utility>
+#include <cmath>
+
+using namespace uhd;
+using namespace uhd::usrp;
+using namespace boost::assign;
+
+/***********************************************************************
+ * The DBSRX constants
+ **********************************************************************/
+static const bool dbsrx_debug = false;
+
+static const freq_range_t dbsrx_freq_range(0.8e9, 2.4e9);
+
+static const freq_range_t dbsrx_pfd_freq_range(0.15e6, 2.01e6);
+
+static const prop_names_t dbsrx_antennas = list_of("J3");
+
+static const uhd::dict<std::string, gain_range_t> dbsrx_gain_ranges = map_list_of
+    ("GC1", gain_range_t(0, 56, 0.5))
+    ("GC2", gain_range_t(0, 24, 1))
+;
+
+/***********************************************************************
+ * The DBSRX dboard class
+ **********************************************************************/
+class dbsrx : public rx_dboard_base{
+public:
+    dbsrx(ctor_args_t args, boost::uint8_t max2118_addr);
+    ~dbsrx(void);
+
+    void rx_get(const wax::obj &key, wax::obj &val);
+    void rx_set(const wax::obj &key, const wax::obj &val);
+
+private:
+    double _lo_freq;
+    float _bandwidth;
+    uhd::dict<std::string, float> _gains;
+    max2118_write_regs_t _max2118_write_regs;
+    max2118_read_regs_t _max2118_read_regs;
+    boost::uint8_t _max2118_addr; //0x67 or 0x65 depending on which side
+
+    void set_lo_freq(double target_freq);
+    void set_gain(float gain, const std::string &name);
+    void set_bandwidth(float bandwidth);
+
+    void send_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){
+        start_reg = boost::uint8_t(std::clip(int(start_reg), 0x0, 0x5));
+        stop_reg = boost::uint8_t(std::clip(int(stop_reg), 0x0, 0x5));
+
+        for(boost::uint8_t start_addr=start_reg; start_addr <= stop_reg; start_addr += sizeof(boost::uint32_t) - 1){
+            int num_bytes = int(stop_reg - start_addr + 1) > int(sizeof(boost::uint32_t)) - 1 ? sizeof(boost::uint32_t) - 1 : stop_reg - start_addr + 1;
+
+            //create buffer for register data (+1 for start address)
+            byte_vector_t regs_vector(num_bytes + 1);
+
+            //first byte is the address of first register
+            regs_vector[0] = start_addr;
+
+            //get the register data
+            for(int i=0; i<num_bytes; i++){
+                regs_vector[1+i] = _max2118_write_regs.get_reg(start_addr+i);
+                if(dbsrx_debug) std::cerr << boost::format(
+                    "DBSRX: send reg 0x%02x, value 0x%04x, start_addr = 0x%04x, num_bytes %d"
+                ) % int(start_addr+i) % int(regs_vector[1+i]) % int(start_addr) % num_bytes << std::endl;
+            }
+
+            //send the data
+            this->get_iface()->write_i2c(
+                _max2118_addr, regs_vector
+            );
+        }
+    }
+
+    void read_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){
+        static const boost::uint8_t status_addr = 0x0;
+        start_reg = boost::uint8_t(std::clip(int(start_reg), 0x0, 0x1));
+        stop_reg = boost::uint8_t(std::clip(int(stop_reg), 0x0, 0x1));
+
+        for(boost::uint8_t start_addr=start_reg; start_addr <= stop_reg; start_addr += sizeof(boost::uint32_t)){
+            int num_bytes = int(stop_reg - start_addr + 1) > int(sizeof(boost::uint32_t)) ? sizeof(boost::uint32_t) : stop_reg - start_addr + 1;
+
+            //create buffer for register data
+            byte_vector_t regs_vector(num_bytes);
+
+            //read from i2c
+            regs_vector = this->get_iface()->read_i2c(
+                _max2118_addr, num_bytes
+            );
+
+            for(boost::uint8_t i=0; i < num_bytes; i++){
+                if (i + start_addr >= status_addr){
+                    _max2118_read_regs.set_reg(i + start_addr, regs_vector[i]);
+                }
+                if(dbsrx_debug) std::cerr << boost::format(
+                    "DBSRX: read reg 0x%02x, value 0x%04x, start_addr = 0x%04x, num_bytes %d"
+                ) % int(start_addr+i) % int(regs_vector[i]) % int(start_addr) % num_bytes << std::endl;
+            }
+        }
+    }
+
+    /*!
+     * Is the LO locked?
+     * \return true for locked
+     */
+    bool get_locked(void){
+        read_reg(0x0, 0x0);
+
+        //mask and return lock detect
+        bool locked = 5 >= _max2118_read_regs.adc and _max2118_read_regs.adc >= 2;
+
+        if(dbsrx_debug) std::cerr << boost::format(
+            "DBSRX: locked %d"
+        ) % locked << std::endl;
+
+        return locked;
+    }
+
+};
+
+/***********************************************************************
+ * Register the DBSRX dboard
+ **********************************************************************/
+// FIXME 0x67 is the default i2c address on USRP2
+//       need to handle which side for USRP1 with different address
+static dboard_base::sptr make_dbsrx(dboard_base::ctor_args_t args){
+    return dboard_base::sptr(new dbsrx(args, 0x67));
+}
+
+//dbid for USRP2 version
+UHD_STATIC_BLOCK(reg_dbsrx_dboard){
+    //register the factory function for the rx dbid
+    dboard_manager::register_dboard(0x000D, &make_dbsrx, "DBSRX");
+}
+
+//dbid for USRP1 version
+UHD_STATIC_BLOCK(reg_dbsrx_on_usrp1_dboard){
+    //register the factory function for the rx dbid
+    dboard_manager::register_dboard(0x0002, &make_dbsrx, "DBSRX");
+}
+
+/***********************************************************************
+ * Structors
+ **********************************************************************/
+dbsrx::dbsrx(ctor_args_t args, boost::uint8_t max2118_addr) : rx_dboard_base(args){
+    //warn user about incorrect DBID on USRP1, requires R193 populated
+    if (this->get_iface()->get_mboard_name() == "usrp1" and this->get_rx_id() == 0x000D)
+        uhd::print_warning(
+            str(boost::format(
+                "DBSRX: incorrect dbid\n"
+                "%s expects dbid 0x0002 and R193\n"
+                "found dbid == %d\n"
+                "Please see the daughterboard app notes" 
+                ) % (this->get_iface()->get_mboard_name()) % (this->get_rx_id().to_pp_string()))
+        );
+
+    //warn user about incorrect DBID on non-USRP1, requires R194 populated
+    if (this->get_iface()->get_mboard_name() != "usrp1" and this->get_rx_id() == 0x0002)
+        uhd::print_warning(
+            str(boost::format(
+                "DBSRX: incorrect dbid\n"
+                "%s expects dbid 0x000D and R194\n"
+                "found dbid == %d\n"
+                "Please see the daughterboard app notes" 
+                ) % (this->get_iface()->get_mboard_name()) % (this->get_rx_id().to_pp_string()))
+        );
+
+    //enable only the clocks we need
+    this->get_iface()->set_clock_enabled(dboard_iface::UNIT_RX, true);
+
+    //set the gpio directions and atr controls (identically)
+    this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_RX, 0x0); // All unused in atr
+    this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, 0x0); // All Inputs
+
+    //set the i2c address for the max2118
+    _max2118_addr = max2118_addr;
+
+    //send initial register settings
+    this->send_reg(0x0, 0x5);
+
+    //set defaults for LO, gains, and filter bandwidth
+    _bandwidth = 33e6;
+    set_lo_freq(dbsrx_freq_range.min);
+
+    BOOST_FOREACH(const std::string &name, dbsrx_gain_ranges.keys()){
+        set_gain(dbsrx_gain_ranges[name].min, name);
+    }
+
+    set_bandwidth(33e6); // default bandwidth from datasheet
+}
+
+dbsrx::~dbsrx(void){
+}
+
+
+/***********************************************************************
+ * Tuning
+ **********************************************************************/
+void dbsrx::set_lo_freq(double target_freq){
+    target_freq = std::clip(target_freq, dbsrx_freq_range.min, dbsrx_freq_range.max);
+
+    double actual_freq=0.0, pfd_freq=0.0, ref_clock=0.0;
+    int R=0, N=0, r=0, m=0;
+    bool update_filter_settings = false;
+
+    //choose refclock
+    std::vector<double> clock_rates = this->get_iface()->get_clock_rates(dboard_iface::UNIT_RX);
+    BOOST_FOREACH(ref_clock, std::reversed(std::sorted(clock_rates))){
+        if (ref_clock > 27.0e6) continue;
+
+        //choose m_divider such that filter tuning constraint is met
+        m = 31;
+        while ((ref_clock/m < 1e6 or ref_clock/m > 2.5e6) and m > 0){ m--; }
+
+        if(dbsrx_debug) std::cerr << boost::format(
+            "DBSRX: trying ref_clock %f and m_divider %d"
+        ) % (this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX)) % m << std::endl;
+
+        if (m >= 32) continue;
+
+        //choose R
+        for(r = 0; r <= 6; r += 1) {
+            //compute divider from setting
+            R = 1 << (r+1);
+            if (dbsrx_debug) std::cerr << boost::format("DBSRX R:%d\n") % R << std::endl;
+
+            //compute PFD compare frequency = ref_clock/R
+            pfd_freq = ref_clock / R;
+
+            //constrain the PFD frequency to specified range
+            if ((pfd_freq < dbsrx_pfd_freq_range.min) or (pfd_freq > dbsrx_pfd_freq_range.max)) continue;
+
+            //compute N
+            N = int(std::floor(target_freq/pfd_freq));
+
+            //constrain N to specified range
+            if ((N < 256) or (N > 32768)) continue;
+
+            goto done_loop;
+        }
+    } 
+
+    //Assert because we failed to find a suitable combination of ref_clock, R and N 
+    UHD_ASSERT_THROW(ref_clock/(1 << m) < 1e6 or ref_clock/(1 << m) > 2.5e6);
+    UHD_ASSERT_THROW((pfd_freq < dbsrx_pfd_freq_range.min) or (pfd_freq > dbsrx_pfd_freq_range.max));
+    UHD_ASSERT_THROW((N < 256) or (N > 32768));
+    done_loop:
+
+    if(dbsrx_debug) std::cerr << boost::format(
+        "DBSRX: choose ref_clock %f and m_divider %d"
+    ) % (this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX)) % m << std::endl;
+
+    //if ref_clock or m divider changed, we need to update the filter settings
+    if (ref_clock != this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX) or m != _max2118_write_regs.m_divider) update_filter_settings = true;
+
+    //compute resulting output frequency
+    actual_freq = pfd_freq * N;
+
+    //apply ref_clock, R, and N settings
+    this->get_iface()->set_clock_rate(dboard_iface::UNIT_RX, ref_clock);
+    ref_clock = this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX);
+    _max2118_write_regs.m_divider = m;
+    _max2118_write_regs.r_divider = (max2118_write_regs_t::r_divider_t) r;
+    _max2118_write_regs.set_n_divider(N);
+    _max2118_write_regs.ade_vco_ade_read = max2118_write_regs_t::ADE_VCO_ADE_READ_ENABLED;
+    
+    //compute prescaler variables
+    int scaler = actual_freq > 1125e6 ? 2 : 4;
+    _max2118_write_regs.div2 = scaler == 4 ? max2118_write_regs_t::DIV2_DIV4 : max2118_write_regs_t::DIV2_DIV2;
+
+    if(dbsrx_debug) std::cerr << boost::format(
+        "DBSRX: scaler %d, actual_freq %f MHz, register bit: %d"
+    ) % scaler % (actual_freq/1e6) % int(_max2118_write_regs.div2) << std::endl;
+
+    //compute vco frequency and select vco
+    double vco_freq = actual_freq * scaler;
+    if (vco_freq < 2433e6)
+        _max2118_write_regs.osc_band = 0;
+    else if (vco_freq < 2711e6)
+        _max2118_write_regs.osc_band = 1;
+    else if (vco_freq < 3025e6)
+        _max2118_write_regs.osc_band = 2;
+    else if (vco_freq < 3341e6)
+        _max2118_write_regs.osc_band = 3;
+    else if (vco_freq < 3727e6)
+        _max2118_write_regs.osc_band = 4;
+    else if (vco_freq < 4143e6)
+        _max2118_write_regs.osc_band = 5;
+    else if (vco_freq < 4493e6)
+        _max2118_write_regs.osc_band = 6;
+    else
+        _max2118_write_regs.osc_band = 7;
+
+    //send settings over i2c
+    send_reg(0x0, 0x4);
+
+    //check vtune for lock condition
+    read_reg(0x0, 0x0);
+
+    if(dbsrx_debug) std::cerr << boost::format(
+        "DBSRX: initial guess for vco %d, vtune adc %d"
+    ) % int(_max2118_write_regs.osc_band) % int(_max2118_read_regs.adc) << std::endl;
+
+    //if we are out of lock for chosen vco, change vco
+    while ((_max2118_read_regs.adc == 0) or (_max2118_read_regs.adc == 7)){
+
+        //vtune is too low, try lower frequency vco
+        if (_max2118_read_regs.adc == 0){
+            if (_max2118_write_regs.osc_band == 0){
+                uhd::print_warning(
+                    str(boost::format(
+                        "DBSRX: Tuning exceeded vco range, _max2118_write_regs.osc_band == %d\n" 
+                        ) % int(_max2118_write_regs.osc_band))
+                );
+                UHD_ASSERT_THROW(_max2118_read_regs.adc == 0);
+            }
+            if (_max2118_write_regs.osc_band <= 0) break;
+            _max2118_write_regs.osc_band -= 1;
+        }
+
+        //vtune is too high, try higher frequency vco
+        if (_max2118_read_regs.adc == 7){
+            if (_max2118_write_regs.osc_band == 7){
+                uhd::print_warning(
+                    str(boost::format(
+                        "DBSRX: Tuning exceeded vco range, _max2118_write_regs.osc_band == %d\n" 
+                        ) % int(_max2118_write_regs.osc_band))
+                );
+                UHD_ASSERT_THROW(_max2118_read_regs.adc == 0);
+            }
+            if (_max2118_write_regs.osc_band >= 7) break;
+            _max2118_write_regs.osc_band += 1;
+        }
+
+        if(dbsrx_debug) std::cerr << boost::format(
+            "DBSRX: trying vco %d, vtune adc %d"
+        ) % int(_max2118_write_regs.osc_band) % int(_max2118_read_regs.adc) << std::endl;
+
+        //update vco selection and check vtune
+        send_reg(0x2, 0x2);
+        read_reg(0x0, 0x0);
+    }
+      
+    if(dbsrx_debug) std::cerr << boost::format(
+        "DBSRX: final vco %d, vtune adc %d"
+    ) % int(_max2118_write_regs.osc_band) % int(_max2118_read_regs.adc) << std::endl;
+
+    //select charge pump bias current
+    if (_max2118_read_regs.adc <= 2) _max2118_write_regs.cp_current = max2118_write_regs_t::CP_CURRENT_I_CP_100UA;
+    else if (_max2118_read_regs.adc >= 5) _max2118_write_regs.cp_current = max2118_write_regs_t::CP_CURRENT_I_CP_400UA;
+    else _max2118_write_regs.cp_current = max2118_write_regs_t::CP_CURRENT_I_CP_200UA;
+    
+    //update charge pump bias current setting
+    send_reg(0x2, 0x2);
+
+    //compute actual tuned frequency
+    _lo_freq = this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX) / std::pow(2.0,(1 + _max2118_write_regs.r_divider)) * _max2118_write_regs.get_n_divider();
+
+    //debug output of calculated variables
+    if (dbsrx_debug) std::cerr
+        << boost::format("DBSRX tune:\n")
+        << boost::format("    VCO=%d, CP=%d, PFD Freq=%fMHz\n") % int(_max2118_write_regs.osc_band) % _max2118_write_regs.cp_current % (pfd_freq/1e6)
+        << boost::format("    R=%d, N=%f, scaler=%d, div2=%d\n") % R % N % scaler % int(_max2118_write_regs.div2)
+        << boost::format("    Ref    Freq=%fMHz\n") % (ref_clock/1e6)
+        << boost::format("    Target Freq=%fMHz\n") % (target_freq/1e6)
+        << boost::format("    Actual Freq=%fMHz\n") % (_lo_freq/1e6)
+        << std::endl;
+
+    if (update_filter_settings) set_bandwidth(_bandwidth);
+    get_locked();
+}
+
+/***********************************************************************
+ * Gain Handling
+ **********************************************************************/
+/*!
+ * Convert a requested gain for the GC2 vga into the integer register value.
+ * The gain passed into the function will be set to the actual value.
+ * \param gain the requested gain in dB
+ * \return 5 bit the register value
+ */
+static int gain_to_gc2_vga_reg(float &gain){
+    int reg = 0;
+    gain = std::clip<float>(float(boost::math::iround(gain)), dbsrx_gain_ranges["GC2"].min, dbsrx_gain_ranges["GC2"].max);
+
+    // Half dB steps from 0-5dB, 1dB steps from 5-24dB
+    if (gain < 5) {
+        reg = boost::math::iround(31.0 - gain/0.5);
+        gain = float(boost::math::iround(gain) * 0.5);
+    } else {
+        reg = boost::math::iround(22.0 - (gain - 4.0));
+        gain = float(boost::math::iround(gain));
+    }
+
+    if (dbsrx_debug) std::cerr << boost::format(
+        "DBSRX GC2 Gain: %f dB, reg: %d"
+    ) % gain % reg << std::endl;
+
+    return reg;
+}
+
+/*!
+ * Convert a requested gain for the GC1 rf vga into the dac_volts value.
+ * The gain passed into the function will be set to the actual value.
+ * \param gain the requested gain in dB
+ * \return dac voltage value
+ */
+static float gain_to_gc1_rfvga_dac(float &gain){
+    //clip the input
+    gain = std::clip<float>(gain, dbsrx_gain_ranges["GC1"].min, dbsrx_gain_ranges["GC1"].max);
+
+    //voltage level constants
+    static const float max_volts = float(1.2), min_volts = float(2.7);
+    static const float slope = (max_volts-min_volts)/dbsrx_gain_ranges["GC1"].max;
+
+    //calculate the voltage for the aux dac
+    float dac_volts = gain*slope + min_volts;
+
+    if (dbsrx_debug) std::cerr << boost::format(
+        "DBSRX GC1 Gain: %f dB, dac_volts: %f V"
+    ) % gain % dac_volts << std::endl;
+
+    //the actual gain setting
+    gain = (dac_volts - min_volts)/slope;
+
+    return dac_volts;
+}
+
+void dbsrx::set_gain(float gain, const std::string &name){
+    assert_has(dbsrx_gain_ranges.keys(), name, "dbsrx gain name");
+    if (name == "GC2"){
+        _max2118_write_regs.gc2 = gain_to_gc2_vga_reg(gain);
+        send_reg(0x5, 0x5);
+    }
+    else if(name == "GC1"){
+        //write the new voltage to the aux dac
+        this->get_iface()->write_aux_dac(dboard_iface::UNIT_RX, dboard_iface::AUX_DAC_A, gain_to_gc1_rfvga_dac(gain));
+    }
+    else UHD_THROW_INVALID_CODE_PATH();
+    _gains[name] = gain;
+}
+
+/***********************************************************************
+ * Bandwidth Handling
+ **********************************************************************/
+void dbsrx::set_bandwidth(float bandwidth){
+    //clip the input
+    bandwidth = std::clip<float>(bandwidth, 4e6, 33e6);
+
+    double ref_clock = this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX);
+    
+    //NOTE: _max2118_write_regs.m_divider set in set_lo_freq
+
+    //compute f_dac setting
+    _max2118_write_regs.f_dac = std::clip<int>(int((((bandwidth*_max2118_write_regs.m_divider)/ref_clock) - 4)/0.145),0,127);
+
+    //determine actual bandwidth
+    _bandwidth = float((ref_clock/(_max2118_write_regs.m_divider))*(4+0.145*_max2118_write_regs.f_dac));
+
+    if (dbsrx_debug) std::cerr << boost::format(
+        "DBSRX Filter Bandwidth: %f MHz, m: %d, f_dac: %d\n"
+    ) % (_bandwidth/1e6) % int(_max2118_write_regs.m_divider) % int(_max2118_write_regs.f_dac) << std::endl;
+
+    this->send_reg(0x3, 0x4);
+}
+
+/***********************************************************************
+ * RX Get and Set
+ **********************************************************************/
+void dbsrx::rx_get(const wax::obj &key_, wax::obj &val){
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+
+    //handle the get request conditioned on the key
+    switch(key.as<subdev_prop_t>()){
+    case SUBDEV_PROP_NAME:
+        val = get_rx_id().to_pp_string();
+        return;
+
+    case SUBDEV_PROP_OTHERS:
+        val = prop_names_t(); //empty
+        return;
+
+    case SUBDEV_PROP_GAIN:
+        assert_has(_gains.keys(), name, "dbsrx gain name");
+        val = _gains[name];
+        return;
+
+    case SUBDEV_PROP_GAIN_RANGE:
+        assert_has(dbsrx_gain_ranges.keys(), name, "dbsrx gain name");
+        val = dbsrx_gain_ranges[name];
+        return;
+
+    case SUBDEV_PROP_GAIN_NAMES:
+        val = prop_names_t(dbsrx_gain_ranges.keys());
+        return;
+
+    case SUBDEV_PROP_FREQ:
+        val = _lo_freq;
+        return;
+
+    case SUBDEV_PROP_FREQ_RANGE:
+        val = dbsrx_freq_range;
+        return;
+
+    case SUBDEV_PROP_ANTENNA:
+        val = std::string("J3");
+        return;
+
+    case SUBDEV_PROP_ANTENNA_NAMES:
+        val = dbsrx_antennas;
+        return;
+
+/*
+    case SUBDEV_PROP_QUADRATURE:
+        val = true;
+        return;
+
+    case SUBDEV_PROP_IQ_SWAPPED:
+        val = false;
+        return;
+
+    case SUBDEV_PROP_SPECTRUM_INVERTED:
+        val = false;
+        return;
+*/
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_IQ;
+        return;
+
+    case SUBDEV_PROP_USE_LO_OFFSET:
+        val = false;
+        return;
+
+    case SUBDEV_PROP_LO_LOCKED:
+        val = this->get_locked();
+        return;
+
+/*
+    case SUBDEV_PROP_RSSI:
+        val = this->get_rssi();
+        return;
+*/
+
+    case SUBDEV_PROP_BANDWIDTH:
+        val = _bandwidth;
+        return;
+
+    default: UHD_THROW_PROP_GET_ERROR();
+    }
+}
+
+void dbsrx::rx_set(const wax::obj &key_, const wax::obj &val){
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+
+    //handle the get request conditioned on the key
+    switch(key.as<subdev_prop_t>()){
+
+    case SUBDEV_PROP_FREQ:
+        this->set_lo_freq(val.as<double>());
+        return;
+
+    case SUBDEV_PROP_GAIN:
+        this->set_gain(val.as<float>(), name);
+        return;
+
+    case SUBDEV_PROP_BANDWIDTH:
+        this->set_bandwidth(val.as<float>());
+        return;
+
+    default: UHD_THROW_PROP_SET_ERROR();
+    }
+}
+
diff --git a/host/lib/usrp/dboard/db_rfx.cpp b/host/lib/usrp/dboard/db_rfx.cpp
index 2d6088983..b6b44199a 100644
--- a/host/lib/usrp/dboard/db_rfx.cpp
+++ b/host/lib/usrp/dboard/db_rfx.cpp
@@ -43,6 +43,7 @@
 #include <uhd/utils/assert.hpp>
 #include <uhd/utils/static.hpp>
 #include <uhd/utils/algorithm.hpp>
+#include <uhd/usrp/dboard_id.hpp>
 #include <uhd/usrp/dboard_base.hpp>
 #include <uhd/usrp/dboard_manager.hpp>
 #include <boost/assign/list_of.hpp>
@@ -65,6 +66,10 @@ static const prop_names_t rfx_rx_antennas = list_of("TX/RX")("RX2");
 static const uhd::dict<std::string, gain_range_t> rfx_tx_gain_ranges; //empty
 
 static const uhd::dict<std::string, gain_range_t> rfx_rx_gain_ranges = map_list_of
+    ("PGA0", gain_range_t(0, 70, float(0.022)))
+;
+
+static const uhd::dict<std::string, gain_range_t> rfx400_rx_gain_ranges = map_list_of
     ("PGA0", gain_range_t(0, 45, float(0.022)))
 ;
 
@@ -88,6 +93,7 @@ public:
 
 private:
     freq_range_t _freq_range;
+    uhd::dict<std::string, gain_range_t> _rx_gain_ranges;
     uhd::dict<dboard_iface::unit_t, bool> _div2;
     double       _rx_lo_freq, _tx_lo_freq;
     std::string  _rx_ant;
@@ -166,6 +172,14 @@ rfx_xcvr::rfx_xcvr(
     _div2[dboard_iface::UNIT_RX] = rx_div2;
     _div2[dboard_iface::UNIT_TX] = tx_div2;
 
+    if(this->get_rx_id() == 0x0024) { //RFX400
+        _rx_gain_ranges = rfx400_rx_gain_ranges;
+    }
+    else {
+        _rx_gain_ranges = rfx_rx_gain_ranges;
+    }
+
+
     //enable the clocks that we need
     this->get_iface()->set_clock_enabled(dboard_iface::UNIT_TX, true);
     this->get_iface()->set_clock_enabled(dboard_iface::UNIT_RX, true);
@@ -193,8 +207,8 @@ rfx_xcvr::rfx_xcvr(
     set_tx_lo_freq((_freq_range.min + _freq_range.max)/2.0);
     set_rx_ant("RX2");
 
-    BOOST_FOREACH(const std::string &name, rfx_rx_gain_ranges.keys()){
-        set_rx_gain(rfx_rx_gain_ranges[name].min, name);
+    BOOST_FOREACH(const std::string &name, _rx_gain_ranges.keys()){
+        set_rx_gain(_rx_gain_ranges[name].min, name);
     }
 }
 
@@ -227,10 +241,10 @@ void rfx_xcvr::set_tx_ant(const std::string &ant){
 /***********************************************************************
  * Gain Handling
  **********************************************************************/
-static float rx_pga0_gain_to_dac_volts(float &gain){
+static float rx_pga0_gain_to_dac_volts(float &gain, float range){
     //voltage level constants (negative slope)
     static const float max_volts = float(.2), min_volts = float(1.2);
-    static const float slope = (max_volts-min_volts)/45;
+    static const float slope = (max_volts-min_volts)/(range);
 
     //calculate the voltage for the aux dac
     float dac_volts = std::clip<float>(gain*slope + min_volts, max_volts, min_volts);
@@ -247,9 +261,10 @@ void rfx_xcvr::set_tx_gain(float, const std::string &name){
 }
 
 void rfx_xcvr::set_rx_gain(float gain, const std::string &name){
-    assert_has(rfx_rx_gain_ranges.keys(), name, "rfx rx gain name");
+    assert_has(_rx_gain_ranges.keys(), name, "rfx rx gain name");
     if(name == "PGA0"){
-        float dac_volts = rx_pga0_gain_to_dac_volts(gain);
+        float dac_volts = rx_pga0_gain_to_dac_volts(gain, 
+                              (_rx_gain_ranges["PGA0"].max - _rx_gain_ranges["PGA0"].min));
         _rx_gains[name] = gain;
 
         //write the new voltage to the aux dac
@@ -402,12 +417,12 @@ void rfx_xcvr::rx_get(const wax::obj &key_, wax::obj &val){
         return;
 
     case SUBDEV_PROP_GAIN_RANGE:
-        assert_has(rfx_rx_gain_ranges.keys(), name, "rfx rx gain name");
-        val = rfx_rx_gain_ranges[name];
+        assert_has(_rx_gain_ranges.keys(), name, "rfx rx gain name");
+        val = _rx_gain_ranges[name];
         return;
 
     case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(rfx_rx_gain_ranges.keys());
+        val = prop_names_t(_rx_gain_ranges.keys());
         return;
 
     case SUBDEV_PROP_FREQ:
@@ -426,16 +441,8 @@ void rfx_xcvr::rx_get(const wax::obj &key_, wax::obj &val){
         val = rfx_rx_antennas;
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_QI;
         return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
@@ -516,16 +523,8 @@ void rfx_xcvr::tx_get(const wax::obj &key_, wax::obj &val){
         val = rfx_tx_antennas;
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_IQ;
         return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
diff --git a/host/lib/usrp/dboard/db_unknown.cpp b/host/lib/usrp/dboard/db_unknown.cpp
index ced27e34d..9dd9b550b 100644
--- a/host/lib/usrp/dboard/db_unknown.cpp
+++ b/host/lib/usrp/dboard/db_unknown.cpp
@@ -119,16 +119,8 @@ void unknown_rx::rx_get(const wax::obj &key_, wax::obj &val){
         val = prop_names_t(1, ""); //vector of 1 empty string
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_IQ;
         return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
@@ -218,16 +210,8 @@ void unknown_tx::tx_get(const wax::obj &key_, wax::obj &val){
         val = prop_names_t(1, ""); //vector of 1 empty string
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_IQ;
         return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
diff --git a/host/lib/usrp/dboard/db_wbx.cpp b/host/lib/usrp/dboard/db_wbx.cpp
index 2b2822b6b..3038ce30b 100644
--- a/host/lib/usrp/dboard/db_wbx.cpp
+++ b/host/lib/usrp/dboard/db_wbx.cpp
@@ -86,7 +86,7 @@ using namespace boost::assign;
  **********************************************************************/
 static const bool wbx_debug = false;
 
-static const freq_range_t wbx_freq_range(50e6, 2.22e9);
+static const freq_range_t wbx_freq_range(68.75e6, 2.2e9);
 
 static const prop_names_t wbx_tx_antennas = list_of("TX/RX");
 
@@ -439,6 +439,7 @@ double wbx_xcvr::set_lo_freq(
     regs.reference_divide_by_2 = T;
     regs.reference_doubler = D;
     regs.band_select_clock_div = BS;
+    UHD_ASSERT_THROW(rfdivsel_to_enum.has_key(RFdiv));
     regs.rf_divider_select = rfdivsel_to_enum[RFdiv];
 
     //write the registers
@@ -509,16 +510,8 @@ void wbx_xcvr::rx_get(const wax::obj &key_, wax::obj &val){
         val = wbx_rx_antennas;
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_IQ;
         return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
@@ -603,16 +596,8 @@ void wbx_xcvr::tx_get(const wax::obj &key_, wax::obj &val){
         val = wbx_tx_antennas;
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_IQ;
         return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
diff --git a/host/lib/usrp/dboard/db_xcvr2450.cpp b/host/lib/usrp/dboard/db_xcvr2450.cpp
index 5032b6f31..2c94bcd2d 100644
--- a/host/lib/usrp/dboard/db_xcvr2450.cpp
+++ b/host/lib/usrp/dboard/db_xcvr2450.cpp
@@ -481,16 +481,8 @@ void xcvr2450::rx_get(const wax::obj &key_, wax::obj &val){
         val = xcvr_antennas;
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_IQ;
         return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
@@ -579,16 +571,8 @@ void xcvr2450::tx_get(const wax::obj &key_, wax::obj &val){
         val = xcvr_antennas;
         return;
 
-    case SUBDEV_PROP_QUADRATURE:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_IQ_SWAPPED:
-        val = true;
-        return;
-
-    case SUBDEV_PROP_SPECTRUM_INVERTED:
-        val = false;
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_QI;
         return;
 
     case SUBDEV_PROP_USE_LO_OFFSET:
diff --git a/host/lib/usrp/dboard_base.cpp b/host/lib/usrp/dboard_base.cpp
index eafb8897f..6c4e29d9e 100644
--- a/host/lib/usrp/dboard_base.cpp
+++ b/host/lib/usrp/dboard_base.cpp
@@ -26,12 +26,12 @@ using namespace uhd::usrp;
  * dboard_base dboard dboard_base class
  **********************************************************************/
 struct dboard_base::impl{
-    ctor_args_impl args;
-    impl(ctor_args_t args) : args(*args){}
+    dboard_ctor_args_t args;
 };
 
 dboard_base::dboard_base(ctor_args_t args){
-    _impl = UHD_PIMPL_MAKE(impl, (args));
+    _impl = UHD_PIMPL_MAKE(impl, ());
+    _impl->args = *static_cast<dboard_ctor_args_t *>(args);
 }
 
 dboard_base::~dboard_base(void){
diff --git a/host/lib/usrp/dboard_ctor_args.hpp b/host/lib/usrp/dboard_ctor_args.hpp
index 13abe79e8..708f2ea08 100644
--- a/host/lib/usrp/dboard_ctor_args.hpp
+++ b/host/lib/usrp/dboard_ctor_args.hpp
@@ -15,18 +15,22 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#ifndef INCLUDED_DBOARD_CTOR_ARGS_HPP
-#define INCLUDED_DBOARD_CTOR_ARGS_HPP
+#ifndef INCLUDED_LIBUHD_USRP_DBOARD_CTOR_ARGS_HPP
+#define INCLUDED_LIBUHD_USRP_DBOARD_CTOR_ARGS_HPP
 
 #include <uhd/usrp/dboard_id.hpp>
 #include <uhd/usrp/dboard_base.hpp>
 #include <uhd/usrp/dboard_iface.hpp>
 #include <string>
 
-struct uhd::usrp::dboard_base::ctor_args_impl{
-    std::string               sd_name;
-    dboard_iface::sptr        db_iface;
-    dboard_id_t               rx_id, tx_id;
-};
+namespace uhd{ namespace usrp{
 
-#endif /* INCLUDED_DBOARD_CTOR_ARGS_HPP */
+    struct dboard_ctor_args_t{
+        std::string               sd_name;
+        dboard_iface::sptr        db_iface;
+        dboard_id_t               rx_id, tx_id;
+    };
+
+}} //namespace
+
+#endif /* INCLUDED_LIBUHD_USRP_DBOARD_CTOR_ARGS_HPP */
diff --git a/host/lib/usrp/dboard_manager.cpp b/host/lib/usrp/dboard_manager.cpp
index 6321e018f..ab80875f5 100644
--- a/host/lib/usrp/dboard_manager.cpp
+++ b/host/lib/usrp/dboard_manager.cpp
@@ -18,7 +18,6 @@
 #include "dboard_ctor_args.hpp"
 #include <uhd/usrp/dboard_manager.hpp>
 #include <uhd/usrp/subdev_props.hpp>
-#include <uhd/utils/gain_handler.hpp>
 #include <uhd/utils/static.hpp>
 #include <uhd/utils/assert.hpp>
 #include <uhd/types/dict.hpp>
@@ -98,33 +97,18 @@ public:
     enum type_t{RX_TYPE, TX_TYPE};
 
     //structors
-    subdev_proxy(dboard_base::sptr subdev, type_t type)
-    : _subdev(subdev), _type(type){
-        //initialize gain props struct
-        gain_handler::props_t gain_props;
-        gain_props.value = SUBDEV_PROP_GAIN;
-        gain_props.range = SUBDEV_PROP_GAIN_RANGE;
-        gain_props.names = SUBDEV_PROP_GAIN_NAMES;
-
-        //make a new gain handler
-        _gain_handler = gain_handler::make(
-            this->get_link(), gain_props,
-            boost::bind(&gain_handler::is_equal<subdev_prop_t>, _1, _2)
-        );
-    }
-
-    ~subdev_proxy(void){
+    subdev_proxy(dboard_base::sptr subdev, type_t type):
+        _subdev(subdev), _type(type)
+    {
         /* NOP */
     }
 
 private:
-    gain_handler::sptr   _gain_handler;
     dboard_base::sptr   _subdev;
     type_t              _type;
 
     //forward the get calls to the rx or tx
     void get(const wax::obj &key, wax::obj &val){
-        if (_gain_handler->intercept_get(key, val)) return;
         switch(_type){
         case RX_TYPE: return _subdev->rx_get(key, val);
         case TX_TYPE: return _subdev->tx_get(key, val);
@@ -133,7 +117,6 @@ private:
 
     //forward the set calls to the rx or tx
     void set(const wax::obj &key, const wax::obj &val){
-        if (_gain_handler->intercept_set(key, val)) return;
         switch(_type){
         case RX_TYPE: return _subdev->rx_set(key, val);
         case TX_TYPE: return _subdev->tx_set(key, val);
@@ -242,7 +225,7 @@ dboard_manager_impl::dboard_manager_impl(
     set_nice_dboard_if();
 
     //dboard constructor args
-    dboard_base::ctor_args_impl db_ctor_args;
+    dboard_ctor_args_t db_ctor_args;
     db_ctor_args.db_iface = iface;
 
     //make xcvr subdevs (make one subdev for both rx and tx dboards)
diff --git a/host/lib/usrp/dsp_utils.hpp b/host/lib/usrp/dsp_utils.hpp
index 13186f354..ebed12c41 100644
--- a/host/lib/usrp/dsp_utils.hpp
+++ b/host/lib/usrp/dsp_utils.hpp
@@ -22,6 +22,7 @@
 #include <uhd/types/dict.hpp>
 #include <uhd/utils/assert.hpp>
 #include <uhd/types/stream_cmd.hpp>
+#include <uhd/usrp/subdev_props.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/assign/list_of.hpp>
 #include <boost/tuple/tuple.hpp>
@@ -37,37 +38,36 @@ namespace dsp_type1{
 
     /*!
      * Calculate the rx mux word from properties.
-     * \param is_quadrature true if the subdev is complex
-     * \param is_iq_swapped true if the i and q are reversed
+     * \param subdev_conn the subdev connection type
      * \param the 32-bit rx mux control word
      */
     static inline boost::uint32_t calc_rx_mux_word(
-        bool is_quadrature,
-        bool is_iq_swapped
+        subdev_conn_t subdev_conn
     ){
-        boost::uint32_t rx_mux = 0;
-        if (is_quadrature){
-            rx_mux = (0x01 << 2) | (0x00 << 0); //Q=ADC1, I=ADC0
-        }else{
-            rx_mux = (0x11 << 2) | (0x00 << 0); //Q=ZERO, I=ADC0
+        switch(subdev_conn){
+        case SUBDEV_CONN_COMPLEX_IQ: return (0x1 << 2) | (0x0 << 0); //DDC0Q=ADC1, DDC0I=ADC0
+        case SUBDEV_CONN_COMPLEX_QI: return (0x0 << 2) | (0x1 << 0); //DDC0Q=ADC0, DDC0I=ADC1
+        case SUBDEV_CONN_REAL_I:     return (0x3 << 2) | (0x0 << 0); //DDC0Q=ZERO, DDC0I=ADC0
+        case SUBDEV_CONN_REAL_Q:     return (0x1 << 2) | (0x3 << 0); //DDC0Q=ADC1, DDC0I=ZERO
+        default:                     UHD_THROW_INVALID_CODE_PATH();
         }
-        if (is_iq_swapped){
-            rx_mux = (rx_mux << 2) | (rx_mux >> 2);
-        }
-        return rx_mux;
     }
 
     /*!
      * Calculate the tx mux word from properties.
-     * \param is_iq_swapped true if the i and q are reversed
+     * \param subdev_conn the subdev connection type
      * \param the 32-bit tx mux control word
      */
-    static inline boost::uint32_t calc_tx_mux_word(bool is_iq_swapped){
-        boost::uint32_t tx_mux = 0x10;
-        if (is_iq_swapped){
-            tx_mux = (tx_mux << 4) | (tx_mux >> 4);
+    static inline boost::uint32_t calc_tx_mux_word(
+        subdev_conn_t subdev_conn
+    ){
+        switch(subdev_conn){
+        case SUBDEV_CONN_COMPLEX_IQ: return (0x1 << 4) | (0x0 << 0); //DAC1=DUC0Q, DAC0=DUC0I
+        case SUBDEV_CONN_COMPLEX_QI: return (0x0 << 4) | (0x1 << 0); //DAC1=DUC0I, DAC0=DUC0Q
+        case SUBDEV_CONN_REAL_I:     return (0xf << 4) | (0x0 << 0); //DAC1=ZERO,  DAC0=DUC0I
+        case SUBDEV_CONN_REAL_Q:     return (0x0 << 4) | (0xf << 0); //DAC1=DUC0I, DAC0=ZERO
+        default:                     UHD_THROW_INVALID_CODE_PATH();
         }
-        return tx_mux;
     }
 
     /*!
@@ -82,11 +82,11 @@ namespace dsp_type1{
         double &freq,
         double codec_rate
     ){
-        UHD_ASSERT_THROW(std::abs(freq) < codec_rate/2.0);
+        UHD_ASSERT_THROW(std::abs(freq) <= codec_rate/2.0);
         static const double scale_factor = std::pow(2.0, 32);
 
         //calculate the freq register word (signed)
-        boost::int32_t freq_word = boost::math::iround((freq / codec_rate) * scale_factor);
+        boost::int32_t freq_word = boost::int32_t(boost::math::round((freq / codec_rate) * scale_factor));
 
         //update the actual frequency
         freq = (double(freq_word) / scale_factor) * codec_rate;
diff --git a/host/lib/usrp/mimo_usrp.cpp b/host/lib/usrp/mimo_usrp.cpp
index b40f98226..e78d38fc0 100644
--- a/host/lib/usrp/mimo_usrp.cpp
+++ b/host/lib/usrp/mimo_usrp.cpp
@@ -18,7 +18,9 @@
 #include <uhd/usrp/mimo_usrp.hpp>
 #include <uhd/usrp/tune_helper.hpp>
 #include <uhd/utils/assert.hpp>
+#include <uhd/utils/gain_group.hpp>
 #include <uhd/utils/algorithm.hpp>
+#include <uhd/utils/warning.hpp>
 #include <uhd/usrp/subdev_props.hpp>
 #include <uhd/usrp/mboard_props.hpp>
 #include <uhd/usrp/device_props.hpp>
@@ -33,6 +35,11 @@
 using namespace uhd;
 using namespace uhd::usrp;
 
+static inline freq_range_t add_dsp_shift(const freq_range_t &range, wax::obj dsp){
+    double codec_rate = dsp[DSP_PROP_CODEC_RATE].as<double>();
+    return freq_range_t(range.min - codec_rate/2.0, range.max + codec_rate/2.0);
+}
+
 /***********************************************************************
  * MIMO USRP Implementation
  **********************************************************************/
@@ -41,29 +48,12 @@ public:
     mimo_usrp_impl(const device_addr_t &addr){
         _dev = device::make(addr);
 
-        //extract each mboard and its sub-devices
-        BOOST_FOREACH(const std::string &name, (*_dev)[DEVICE_PROP_MBOARD_NAMES].as<prop_names_t>()){
-            _mboards.push_back((*_dev)[named_prop_t(DEVICE_PROP_MBOARD, name)]);
-            _rx_dsps.push_back(_mboards.back()[MBOARD_PROP_RX_DSP]);
-            _tx_dsps.push_back(_mboards.back()[MBOARD_PROP_TX_DSP]);
-
-            //extract rx subdevice
-            _rx_dboards.push_back(_mboards.back()[MBOARD_PROP_RX_DBOARD]);
-            std::string rx_subdev_in_use = _rx_dboards.back()[DBOARD_PROP_USED_SUBDEVS].as<prop_names_t>().at(0);
-            _rx_subdevs.push_back(_rx_dboards.back()[named_prop_t(DBOARD_PROP_SUBDEV, rx_subdev_in_use)]);
-
-            //extract tx subdevice
-            _tx_dboards.push_back(_mboards.back()[MBOARD_PROP_TX_DBOARD]);
-            std::string tx_subdev_in_use = _tx_dboards.back()[DBOARD_PROP_USED_SUBDEVS].as<prop_names_t>().at(0);
-            _tx_subdevs.push_back(_tx_dboards.back()[named_prop_t(DBOARD_PROP_SUBDEV, tx_subdev_in_use)]);
-        }
-
         //set the clock config across all mboards (TODO set through api)
         clock_config_t clock_config;
         clock_config.ref_source = clock_config_t::REF_SMA;
         clock_config.pps_source = clock_config_t::PPS_SMA;
-        BOOST_FOREACH(wax::obj mboard, _mboards){
-            mboard[MBOARD_PROP_CLOCK_CONFIG] = clock_config;
+        for (size_t chan = 0; chan < get_num_channels(); chan++){
+            _mboard(chan)[MBOARD_PROP_CLOCK_CONFIG] = clock_config;
         }
     }
 
@@ -82,7 +72,7 @@ public:
         )
             % (*_dev)[DEVICE_PROP_NAME].as<std::string>()
         );
-        for (size_t i = 0; i < get_num_channels(); i++){
+        for (size_t chan = 0; chan < get_num_channels(); chan++){
             buff += str(boost::format(
                 "  Channel: %u\n"
                 "    Mboard: %s\n"
@@ -92,21 +82,21 @@ public:
                 "    TX DSP: %s\n"
                 "    TX Dboard: %s\n"
                 "    TX Subdev: %s\n"
-            ) % i
-                % _mboards.at(i)[MBOARD_PROP_NAME].as<std::string>()
-                % _rx_dsps.at(i)[DSP_PROP_NAME].as<std::string>()
-                % _rx_dboards.at(i)[DBOARD_PROP_NAME].as<std::string>()
-                % _rx_subdevs.at(i)[SUBDEV_PROP_NAME].as<std::string>()
-                % _tx_dsps.at(i)[DSP_PROP_NAME].as<std::string>()
-                % _tx_dboards.at(i)[DBOARD_PROP_NAME].as<std::string>()
-                % _tx_subdevs.at(i)[SUBDEV_PROP_NAME].as<std::string>()
+            ) % chan
+                % _mboard(chan)[MBOARD_PROP_NAME].as<std::string>()
+                % _rx_dsp(chan)[DSP_PROP_NAME].as<std::string>()
+                % _rx_dboard(chan)[DBOARD_PROP_NAME].as<std::string>()
+                % _rx_subdev(chan)[SUBDEV_PROP_NAME].as<std::string>()
+                % _tx_dsp(chan)[DSP_PROP_NAME].as<std::string>()
+                % _tx_dboard(chan)[DBOARD_PROP_NAME].as<std::string>()
+                % _tx_subdev(chan)[SUBDEV_PROP_NAME].as<std::string>()
             );
         }
         return buff;
     }
 
     size_t get_num_channels(void){
-        return _mboards.size();
+        return (*_dev)[DEVICE_PROP_MBOARD_NAMES].as<prop_names_t>().size();
     }
 
     /*******************************************************************
@@ -114,12 +104,12 @@ public:
      ******************************************************************/
     time_spec_t get_time_now(void){
         //the time on the first mboard better be the same on all
-        return _mboards.front()[MBOARD_PROP_TIME_NOW].as<time_spec_t>();
+        return _mboard(0)[MBOARD_PROP_TIME_NOW].as<time_spec_t>();
     }
 
     void set_time_next_pps(const time_spec_t &time_spec){
-        BOOST_FOREACH(wax::obj mboard, _mboards){
-            mboard[MBOARD_PROP_TIME_NEXT_PPS] = time_spec;
+        for (size_t chan = 0; chan < get_num_channels(); chan++){
+            _mboard(chan)[MBOARD_PROP_TIME_NEXT_PPS] = time_spec;
         }
     }
 
@@ -141,33 +131,42 @@ public:
         boost::this_thread::sleep(boost::posix_time::seconds(1));
 
         //verify that the time registers are read to be within a few RTT
-        for (size_t i = 1; i < get_num_channels(); i++){
-            time_spec_t time_0 = _mboards.front()[MBOARD_PROP_TIME_NOW].as<time_spec_t>();
-            time_spec_t time_i = _mboards.at(i)[MBOARD_PROP_TIME_NOW].as<time_spec_t>();
+        for (size_t chan = 1; chan < get_num_channels(); chan++){
+            time_spec_t time_0 = _mboard(0)[MBOARD_PROP_TIME_NOW].as<time_spec_t>();
+            time_spec_t time_i = _mboard(chan)[MBOARD_PROP_TIME_NOW].as<time_spec_t>();
             if (time_i < time_0 or (time_i - time_0) > time_spec_t(0.01)){ //10 ms: greater than RTT but not too big
-                std::cerr << boost::format(
-                    "Error: time deviation between board %d and board 0.\n"
-                    "    Board 0 time is %f seconds.\n"
-                    "    Board %d time is %f seconds.\n"
-                ) % i % time_0.get_real_secs() % i % time_i.get_real_secs() << std::endl;
+                uhd::print_warning(str(boost::format(
+                    "Detected time deviation between board %d and board 0.\n"
+                    "Board 0 time is %f seconds.\n"
+                    "Board %d time is %f seconds.\n"
+                ) % chan % time_0.get_real_secs() % chan % time_i.get_real_secs()));
             }
         }
     }
 
     void issue_stream_cmd(const stream_cmd_t &stream_cmd){
-        BOOST_FOREACH(wax::obj mboard, _mboards){
-            mboard[MBOARD_PROP_STREAM_CMD] = stream_cmd;
+        for (size_t chan = 0; chan < get_num_channels(); chan++){
+            _mboard(chan)[MBOARD_PROP_STREAM_CMD] = stream_cmd;
         }
     }
 
     /*******************************************************************
      * RX methods
      ******************************************************************/
+    void set_rx_subdev_spec(size_t chan, const subdev_spec_t &spec){
+        UHD_ASSERT_THROW(spec.size() <= 1);
+        _mboard(chan)[MBOARD_PROP_RX_SUBDEV_SPEC] = spec;
+    }
+
+    subdev_spec_t get_rx_subdev_spec(size_t chan){
+        return _mboard(chan)[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>();
+    }
+
     void set_rx_rate_all(double rate){
         std::vector<double> _actual_rates;
-        BOOST_FOREACH(wax::obj rx_dsp, _rx_dsps){
-            rx_dsp[DSP_PROP_HOST_RATE] = rate;
-            _actual_rates.push_back(rx_dsp[DSP_PROP_HOST_RATE].as<double>());
+        for (size_t chan = 0; chan < get_num_channels(); chan++){
+            _rx_dsp(chan)[DSP_PROP_HOST_RATE] = rate;
+            _actual_rates.push_back(_rx_dsp(chan)[DSP_PROP_HOST_RATE].as<double>());
         }
         _rx_rate = _actual_rates.front();
         if (std::count(_actual_rates, _rx_rate) != _actual_rates.size()) throw std::runtime_error(
@@ -180,57 +179,70 @@ public:
     }
 
     tune_result_t set_rx_freq(size_t chan, double target_freq){
-        return tune_rx_subdev_and_ddc(_rx_subdevs.at(chan), _rx_dsps.at(chan), target_freq);
+        return tune_rx_subdev_and_dsp(_rx_subdev(chan), _rx_dsp(chan), target_freq);
     }
 
     tune_result_t set_rx_freq(size_t chan, double target_freq, double lo_off){
-        return tune_rx_subdev_and_ddc(_rx_subdevs.at(chan), _rx_dsps.at(chan), target_freq, lo_off);
+        return tune_rx_subdev_and_dsp(_rx_subdev(chan), _rx_dsp(chan), target_freq, lo_off);
+    }
+
+    double get_rx_freq(size_t chan){
+        return derive_freq_from_rx_subdev_and_dsp(_rx_subdev(chan), _rx_dsp(chan));
     }
 
     freq_range_t get_rx_freq_range(size_t chan){
-        return _rx_subdevs.at(chan)[SUBDEV_PROP_FREQ_RANGE].as<freq_range_t>();
+        return add_dsp_shift(_rx_subdev(chan)[SUBDEV_PROP_FREQ_RANGE].as<freq_range_t>(), _rx_dsp(chan));
     }
 
     void set_rx_gain(size_t chan, float gain){
-        _rx_subdevs.at(chan)[SUBDEV_PROP_GAIN] = gain;
+        return _rx_gain_group(chan)->set_value(gain);
     }
 
     float get_rx_gain(size_t chan){
-        return _rx_subdevs.at(chan)[SUBDEV_PROP_GAIN].as<float>();
+        return _rx_gain_group(chan)->get_value();
     }
 
     gain_range_t get_rx_gain_range(size_t chan){
-        return _rx_subdevs.at(chan)[SUBDEV_PROP_GAIN_RANGE].as<gain_range_t>();
+        return _rx_gain_group(chan)->get_range();
     }
 
     void set_rx_antenna(size_t chan, const std::string &ant){
-        _rx_subdevs.at(chan)[SUBDEV_PROP_ANTENNA] = ant;
+        _rx_subdev(chan)[SUBDEV_PROP_ANTENNA] = ant;
     }
 
     std::string get_rx_antenna(size_t chan){
-        return _rx_subdevs.at(chan)[SUBDEV_PROP_ANTENNA].as<std::string>();
+        return _rx_subdev(chan)[SUBDEV_PROP_ANTENNA].as<std::string>();
     }
 
     std::vector<std::string> get_rx_antennas(size_t chan){
-        return _rx_subdevs.at(chan)[SUBDEV_PROP_ANTENNA_NAMES].as<prop_names_t>();
+        return _rx_subdev(chan)[SUBDEV_PROP_ANTENNA_NAMES].as<prop_names_t>();
     }
 
     bool get_rx_lo_locked(size_t chan){
-        return _rx_subdevs.at(chan)[SUBDEV_PROP_LO_LOCKED].as<bool>();
+        return _rx_subdev(chan)[SUBDEV_PROP_LO_LOCKED].as<bool>();
     }
 
     float read_rssi(size_t chan){
-        return _rx_subdevs.at(chan)[SUBDEV_PROP_RSSI].as<float>();
+        return _rx_subdev(chan)[SUBDEV_PROP_RSSI].as<float>();
     }
 
     /*******************************************************************
      * TX methods
      ******************************************************************/
+    void set_tx_subdev_spec(size_t chan, const subdev_spec_t &spec){
+        UHD_ASSERT_THROW(spec.size() <= 1);
+        _mboard(chan)[MBOARD_PROP_TX_SUBDEV_SPEC] = spec;
+    }
+
+    subdev_spec_t get_tx_subdev_spec(size_t chan){
+        return _mboard(chan)[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>();
+    }
+
     void set_tx_rate_all(double rate){
         std::vector<double> _actual_rates;
-        BOOST_FOREACH(wax::obj tx_dsp, _tx_dsps){
-            tx_dsp[DSP_PROP_HOST_RATE] = rate;
-            _actual_rates.push_back(tx_dsp[DSP_PROP_HOST_RATE].as<double>());
+        for (size_t chan = 0; chan < get_num_channels(); chan++){
+            _tx_dsp(chan)[DSP_PROP_HOST_RATE] = rate;
+            _actual_rates.push_back(_tx_dsp(chan)[DSP_PROP_HOST_RATE].as<double>());
         }
         _tx_rate = _actual_rates.front();
         if (std::count(_actual_rates, _tx_rate) != _actual_rates.size()) throw std::runtime_error(
@@ -243,54 +255,85 @@ public:
     }
 
     tune_result_t set_tx_freq(size_t chan, double target_freq){
-        return tune_tx_subdev_and_duc(_tx_subdevs.at(chan), _tx_dsps.at(chan), target_freq);
+        return tune_tx_subdev_and_dsp(_tx_subdev(chan), _tx_dsp(chan), target_freq);
     }
 
     tune_result_t set_tx_freq(size_t chan, double target_freq, double lo_off){
-        return tune_tx_subdev_and_duc(_tx_subdevs.at(chan), _tx_dsps.at(chan), target_freq, lo_off);
+        return tune_tx_subdev_and_dsp(_tx_subdev(chan), _tx_dsp(chan), target_freq, lo_off);
+    }
+
+    double get_tx_freq(size_t chan){
+        return derive_freq_from_tx_subdev_and_dsp(_tx_subdev(chan), _tx_dsp(chan));
     }
 
     freq_range_t get_tx_freq_range(size_t chan){
-        return _tx_subdevs.at(chan)[SUBDEV_PROP_FREQ_RANGE].as<freq_range_t>();
+        return add_dsp_shift(_tx_subdev(chan)[SUBDEV_PROP_FREQ_RANGE].as<freq_range_t>(), _tx_dsp(chan));
     }
 
     void set_tx_gain(size_t chan, float gain){
-        _tx_subdevs.at(chan)[SUBDEV_PROP_GAIN] = gain;
+        return _tx_gain_group(chan)->set_value(gain);
     }
 
     float get_tx_gain(size_t chan){
-        return _tx_subdevs.at(chan)[SUBDEV_PROP_GAIN].as<float>();
+        return _tx_gain_group(chan)->get_value();
     }
 
     gain_range_t get_tx_gain_range(size_t chan){
-        return _tx_subdevs.at(chan)[SUBDEV_PROP_GAIN_RANGE].as<gain_range_t>();
+        return _tx_gain_group(chan)->get_range();
     }
 
     void set_tx_antenna(size_t chan, const std::string &ant){
-        _tx_subdevs.at(chan)[SUBDEV_PROP_ANTENNA] = ant;
+        _tx_subdev(chan)[SUBDEV_PROP_ANTENNA] = ant;
     }
 
     std::string get_tx_antenna(size_t chan){
-        return _tx_subdevs.at(chan)[SUBDEV_PROP_ANTENNA].as<std::string>();
+        return _tx_subdev(chan)[SUBDEV_PROP_ANTENNA].as<std::string>();
     }
 
     std::vector<std::string> get_tx_antennas(size_t chan){
-        return _tx_subdevs.at(chan)[SUBDEV_PROP_ANTENNA_NAMES].as<prop_names_t>();
+        return _tx_subdev(chan)[SUBDEV_PROP_ANTENNA_NAMES].as<prop_names_t>();
     }
 
     bool get_tx_lo_locked(size_t chan){
-        return _tx_subdevs.at(chan)[SUBDEV_PROP_LO_LOCKED].as<bool>();
+        return _tx_subdev(chan)[SUBDEV_PROP_LO_LOCKED].as<bool>();
     }
 
 private:
     device::sptr _dev;
-    std::vector<wax::obj> _mboards;
-    std::vector<wax::obj> _rx_dsps;
-    std::vector<wax::obj> _tx_dsps;
-    std::vector<wax::obj> _rx_dboards;
-    std::vector<wax::obj> _tx_dboards;
-    std::vector<wax::obj> _rx_subdevs;
-    std::vector<wax::obj> _tx_subdevs;
+    wax::obj _mboard(size_t chan){
+        prop_names_t names = (*_dev)[DEVICE_PROP_MBOARD_NAMES].as<prop_names_t>();
+        return (*_dev)[named_prop_t(DEVICE_PROP_MBOARD, names.at(chan))];
+    }
+    wax::obj _rx_dsp(size_t chan){
+        return _mboard(chan)[MBOARD_PROP_RX_DSP];
+    }
+    wax::obj _tx_dsp(size_t chan){
+        return _mboard(chan)[MBOARD_PROP_TX_DSP];
+    }
+    wax::obj _rx_dboard(size_t chan){
+        std::string db_name = _mboard(chan)[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>().front().db_name;
+        return _mboard(chan)[named_prop_t(MBOARD_PROP_RX_DBOARD, db_name)];
+    }
+    wax::obj _tx_dboard(size_t chan){
+        std::string db_name = _mboard(chan)[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>().front().db_name;
+        return _mboard(chan)[named_prop_t(MBOARD_PROP_TX_DBOARD, db_name)];
+    }
+    wax::obj _rx_subdev(size_t chan){
+        std::string sd_name = _mboard(chan)[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>().front().sd_name;
+        return _rx_dboard(chan)[named_prop_t(DBOARD_PROP_SUBDEV, sd_name)];
+    }
+    wax::obj _tx_subdev(size_t chan){
+        std::string sd_name = _mboard(chan)[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>().front().sd_name;
+        return _tx_dboard(chan)[named_prop_t(DBOARD_PROP_SUBDEV, sd_name)];
+    }
+    gain_group::sptr _rx_gain_group(size_t chan){
+        std::string sd_name = _mboard(chan)[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>().front().sd_name;
+        return _rx_dboard(chan)[named_prop_t(DBOARD_PROP_GAIN_GROUP, sd_name)].as<gain_group::sptr>();
+    }
+    gain_group::sptr _tx_gain_group(size_t chan){
+        std::string sd_name = _mboard(chan)[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>().front().sd_name;
+        return _tx_dboard(chan)[named_prop_t(DBOARD_PROP_GAIN_GROUP, sd_name)].as<gain_group::sptr>();
+    }
 
     //shadows
     double _rx_rate, _tx_rate;
diff --git a/host/lib/usrp/misc_utils.cpp b/host/lib/usrp/misc_utils.cpp
new file mode 100644
index 000000000..0aa03a6cc
--- /dev/null
+++ b/host/lib/usrp/misc_utils.cpp
@@ -0,0 +1,114 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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, see <http://www.gnu.org/licenses/>.
+//
+
+#include "misc_utils.hpp"
+#include <uhd/utils/gain_group.hpp>
+#include <uhd/usrp/subdev_props.hpp>
+#include <uhd/usrp/codec_props.hpp>
+#include <boost/bind.hpp>
+#include <boost/foreach.hpp>
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+static const size_t subdev_gain_priority = 1; //higher, closer to the antenna
+static const size_t codec_gain_priority = 0;
+
+/***********************************************************************
+ * codec gain group helper functions:
+ *    do this so we dont have to bind a templated function
+ **********************************************************************/
+static gain_range_t get_codec_gain_range(wax::obj codec, const std::string &name){
+    return codec[named_prop_t(CODEC_PROP_GAIN_RANGE, name)].as<gain_range_t>();
+}
+
+static float get_codec_gain_i(wax::obj codec, const std::string &name){
+    return codec[named_prop_t(CODEC_PROP_GAIN_I, name)].as<float>();
+}
+
+static float get_codec_gain_q(wax::obj codec, const std::string &name){
+    return codec[named_prop_t(CODEC_PROP_GAIN_Q, name)].as<float>();
+}
+
+static void set_codec_gain_both(wax::obj codec, const std::string &name, float gain){
+    codec[named_prop_t(CODEC_PROP_GAIN_I, name)] = gain;
+    codec[named_prop_t(CODEC_PROP_GAIN_Q, name)] = gain;
+}
+
+static void set_codec_gain_i(wax::obj codec, const std::string &name, float gain){
+    codec[named_prop_t(CODEC_PROP_GAIN_I, name)] = gain;
+}
+
+static void set_codec_gain_q(wax::obj codec, const std::string &name, float gain){
+    codec[named_prop_t(CODEC_PROP_GAIN_Q, name)] = gain;
+}
+
+/***********************************************************************
+ * subdev gain group helper functions:
+ *    do this so we dont have to bind a templated function
+ **********************************************************************/
+static float get_subdev_gain(wax::obj subdev, const std::string &name){
+    return subdev[named_prop_t(SUBDEV_PROP_GAIN, name)].as<float>();
+}
+
+static gain_range_t get_subdev_gain_range(wax::obj subdev, const std::string &name){
+    return subdev[named_prop_t(SUBDEV_PROP_GAIN_RANGE, name)].as<gain_range_t>();
+}
+
+static void set_subdev_gain(wax::obj subdev, const std::string &name, float gain){
+    subdev[named_prop_t(SUBDEV_PROP_GAIN, name)] = gain;
+}
+
+/***********************************************************************
+ * gain group factory function for usrp
+ **********************************************************************/
+gain_group::sptr usrp::make_gain_group(wax::obj subdev, wax::obj codec){
+    gain_group::sptr gg = gain_group::make();
+    gain_fcns_t fcns;
+    //add all the subdev gains first (antenna to dsp order)
+    BOOST_FOREACH(const std::string &name, subdev[SUBDEV_PROP_GAIN_NAMES].as<prop_names_t>()){
+        fcns.get_range = boost::bind(&get_subdev_gain_range, subdev, name);
+        fcns.get_value = boost::bind(&get_subdev_gain, subdev, name);
+        fcns.set_value = boost::bind(&set_subdev_gain, subdev, name, _1);
+        gg->register_fcns(fcns, subdev_gain_priority);
+    }
+    //add all the codec gains last (antenna to dsp order)
+    BOOST_FOREACH(const std::string &name, codec[CODEC_PROP_GAIN_NAMES].as<prop_names_t>()){
+        fcns.get_range = boost::bind(&get_codec_gain_range, codec, name);
+
+        //register the value functions depending upon the connection type
+        switch(subdev[SUBDEV_PROP_CONNECTION].as<subdev_conn_t>()){
+        case SUBDEV_CONN_COMPLEX_IQ:
+        case SUBDEV_CONN_COMPLEX_QI:
+            fcns.get_value = boost::bind(&get_codec_gain_i, codec, name); //same as Q
+            fcns.set_value = boost::bind(&set_codec_gain_both, codec, name, _1); //sets both
+            break;
+
+        case SUBDEV_CONN_REAL_I:
+            fcns.get_value = boost::bind(&get_codec_gain_i, codec, name);
+            fcns.set_value = boost::bind(&set_codec_gain_i, codec, name, _1);
+            break;
+
+        case SUBDEV_CONN_REAL_Q:
+            fcns.get_value = boost::bind(&get_codec_gain_q, codec, name);
+            fcns.set_value = boost::bind(&set_codec_gain_q, codec, name, _1);
+            break;
+        }
+        gg->register_fcns(fcns, codec_gain_priority);
+    }
+    return gg;
+}
diff --git a/host/lib/usrp/misc_utils.hpp b/host/lib/usrp/misc_utils.hpp
new file mode 100644
index 000000000..7fe3c899d
--- /dev/null
+++ b/host/lib/usrp/misc_utils.hpp
@@ -0,0 +1,35 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_LIBUHD_USRP_MISC_UTILS_HPP
+#define INCLUDED_LIBUHD_USRP_MISC_UTILS_HPP
+
+#include <uhd/config.hpp>
+#include <uhd/wax.hpp>
+#include <uhd/utils/gain_group.hpp>
+
+namespace uhd{ namespace usrp{
+
+    /*!
+     * Create a gain group that represents the subdevice and its codec.
+     */
+    gain_group::sptr make_gain_group(wax::obj subdev, wax::obj codec);
+
+}} //namespace
+
+#endif /* INCLUDED_LIBUHD_USRP_MISC_UTILS_HPP */
+
diff --git a/host/lib/usrp/simple_usrp.cpp b/host/lib/usrp/simple_usrp.cpp
index 56e82d7ee..60b25a647 100644
--- a/host/lib/usrp/simple_usrp.cpp
+++ b/host/lib/usrp/simple_usrp.cpp
@@ -18,6 +18,7 @@
 #include <uhd/usrp/simple_usrp.hpp>
 #include <uhd/usrp/tune_helper.hpp>
 #include <uhd/utils/assert.hpp>
+#include <uhd/utils/gain_group.hpp>
 #include <uhd/usrp/subdev_props.hpp>
 #include <uhd/usrp/mboard_props.hpp>
 #include <uhd/usrp/device_props.hpp>
@@ -26,10 +27,16 @@
 #include <boost/foreach.hpp>
 #include <boost/format.hpp>
 #include <stdexcept>
+#include <iostream>
 
 using namespace uhd;
 using namespace uhd::usrp;
 
+static inline freq_range_t add_dsp_shift(const freq_range_t &range, wax::obj dsp){
+    double codec_rate = dsp[DSP_PROP_CODEC_RATE].as<double>();
+    return freq_range_t(range.min - codec_rate/2.0, range.max + codec_rate/2.0);
+}
+
 /***********************************************************************
  * Simple USRP Implementation
  **********************************************************************/
@@ -37,19 +44,6 @@ class simple_usrp_impl : public simple_usrp{
 public:
     simple_usrp_impl(const device_addr_t &addr){
         _dev = device::make(addr);
-        _mboard = (*_dev)[DEVICE_PROP_MBOARD];
-        _rx_dsp = _mboard[MBOARD_PROP_RX_DSP];
-        _tx_dsp = _mboard[MBOARD_PROP_TX_DSP];
-
-        //extract rx subdevice
-        _rx_dboard = _mboard[MBOARD_PROP_RX_DBOARD];
-        std::string rx_subdev_in_use = _rx_dboard[DBOARD_PROP_USED_SUBDEVS].as<prop_names_t>().at(0);
-        _rx_subdev = _rx_dboard[named_prop_t(DBOARD_PROP_SUBDEV, rx_subdev_in_use)];
-
-        //extract tx subdevice
-        _tx_dboard = _mboard[MBOARD_PROP_TX_DBOARD];
-        std::string tx_subdev_in_use = _tx_dboard[DBOARD_PROP_USED_SUBDEVS].as<prop_names_t>().at(0);
-        _tx_subdev = _tx_dboard[named_prop_t(DBOARD_PROP_SUBDEV, tx_subdev_in_use)];
     }
 
     ~simple_usrp_impl(void){
@@ -73,13 +67,13 @@ public:
             "  TX Subdev: %s\n"
         )
             % (*_dev)[DEVICE_PROP_NAME].as<std::string>()
-            % _mboard[MBOARD_PROP_NAME].as<std::string>()
-            % _rx_dsp[DSP_PROP_NAME].as<std::string>()
-            % _rx_dboard[DBOARD_PROP_NAME].as<std::string>()
-            % _rx_subdev[SUBDEV_PROP_NAME].as<std::string>()
-            % _tx_dsp[DSP_PROP_NAME].as<std::string>()
-            % _tx_dboard[DBOARD_PROP_NAME].as<std::string>()
-            % _tx_subdev[SUBDEV_PROP_NAME].as<std::string>()
+            % _mboard()[MBOARD_PROP_NAME].as<std::string>()
+            % _rx_dsp()[DSP_PROP_NAME].as<std::string>()
+            % _rx_dboard()[DBOARD_PROP_NAME].as<std::string>()
+            % _rx_subdev()[SUBDEV_PROP_NAME].as<std::string>()
+            % _tx_dsp()[DSP_PROP_NAME].as<std::string>()
+            % _tx_dboard()[DBOARD_PROP_NAME].as<std::string>()
+            % _tx_subdev()[SUBDEV_PROP_NAME].as<std::string>()
         );
     }
 
@@ -87,140 +81,192 @@ public:
      * Misc
      ******************************************************************/
     time_spec_t get_time_now(void){
-        return _mboard[MBOARD_PROP_TIME_NOW].as<time_spec_t>();
+        return _mboard()[MBOARD_PROP_TIME_NOW].as<time_spec_t>();
     }
 
     void set_time_now(const time_spec_t &time_spec){
-        _mboard[MBOARD_PROP_TIME_NOW] = time_spec;
+        _mboard()[MBOARD_PROP_TIME_NOW] = time_spec;
     }
 
     void set_time_next_pps(const time_spec_t &time_spec){
-        _mboard[MBOARD_PROP_TIME_NEXT_PPS] = time_spec;
+        _mboard()[MBOARD_PROP_TIME_NEXT_PPS] = time_spec;
     }
 
     void issue_stream_cmd(const stream_cmd_t &stream_cmd){
-        _mboard[MBOARD_PROP_STREAM_CMD] = stream_cmd;
+        _mboard()[MBOARD_PROP_STREAM_CMD] = stream_cmd;
     }
 
     void set_clock_config(const clock_config_t &clock_config){
-        _mboard[MBOARD_PROP_CLOCK_CONFIG] = clock_config;
+        _mboard()[MBOARD_PROP_CLOCK_CONFIG] = clock_config;
     }
 
     /*******************************************************************
      * RX methods
      ******************************************************************/
+    void set_rx_subdev_spec(const subdev_spec_t &spec){
+        _mboard()[MBOARD_PROP_RX_SUBDEV_SPEC] = spec;
+        std::cout << "RX " << _mboard()[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>().to_pp_string() << std::endl;
+    }
+
+    subdev_spec_t get_rx_subdev_spec(void){
+        return _mboard()[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>();
+    }
+
     void set_rx_rate(double rate){
-        _rx_dsp[DSP_PROP_HOST_RATE] = rate;
+        _rx_dsp()[DSP_PROP_HOST_RATE] = rate;
     }
 
     double get_rx_rate(void){
-        return _rx_dsp[DSP_PROP_HOST_RATE].as<double>();
+        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_dsp, target_freq);
+        return tune_rx_subdev_and_dsp(_rx_subdev(), _rx_dsp(), target_freq);
     }
 
     tune_result_t set_rx_freq(double target_freq, double lo_off){
-        return tune_rx_subdev_and_ddc(_rx_subdev, _rx_dsp, target_freq, lo_off);
+        return tune_rx_subdev_and_dsp(_rx_subdev(), _rx_dsp(), target_freq, lo_off);
+    }
+
+    double get_rx_freq(void){
+        return derive_freq_from_rx_subdev_and_dsp(_rx_subdev(), _rx_dsp());
     }
 
     freq_range_t get_rx_freq_range(void){
-        return _rx_subdev[SUBDEV_PROP_FREQ_RANGE].as<freq_range_t>();
+        return add_dsp_shift(_rx_subdev()[SUBDEV_PROP_FREQ_RANGE].as<freq_range_t>(), _rx_dsp());
     }
 
     void set_rx_gain(float gain){
-        _rx_subdev[SUBDEV_PROP_GAIN] = gain;
+        return _rx_gain_group()->set_value(gain);
     }
 
     float get_rx_gain(void){
-        return _rx_subdev[SUBDEV_PROP_GAIN].as<float>();
+        return _rx_gain_group()->get_value();
     }
 
     gain_range_t get_rx_gain_range(void){
-        return _rx_subdev[SUBDEV_PROP_GAIN_RANGE].as<gain_range_t>();
+        return _rx_gain_group()->get_range();
     }
 
     void set_rx_antenna(const std::string &ant){
-        _rx_subdev[SUBDEV_PROP_ANTENNA] = ant;
+        _rx_subdev()[SUBDEV_PROP_ANTENNA] = ant;
     }
 
     std::string get_rx_antenna(void){
-        return _rx_subdev[SUBDEV_PROP_ANTENNA].as<std::string>();
+        return _rx_subdev()[SUBDEV_PROP_ANTENNA].as<std::string>();
     }
 
     std::vector<std::string> get_rx_antennas(void){
-        return _rx_subdev[SUBDEV_PROP_ANTENNA_NAMES].as<prop_names_t>();
+        return _rx_subdev()[SUBDEV_PROP_ANTENNA_NAMES].as<prop_names_t>();
     }
 
     bool get_rx_lo_locked(void){
-        return _rx_subdev[SUBDEV_PROP_LO_LOCKED].as<bool>();
+        return _rx_subdev()[SUBDEV_PROP_LO_LOCKED].as<bool>();
     }
 
     float read_rssi(void){
-        return _rx_subdev[SUBDEV_PROP_RSSI].as<float>();
+        return _rx_subdev()[SUBDEV_PROP_RSSI].as<float>();
     }
 
     /*******************************************************************
      * TX methods
      ******************************************************************/
+    void set_tx_subdev_spec(const subdev_spec_t &spec){
+        _mboard()[MBOARD_PROP_TX_SUBDEV_SPEC] = spec;
+        std::cout << "TX " << _mboard()[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>().to_pp_string() << std::endl;
+    }
+
+    subdev_spec_t get_tx_subdev_spec(void){
+        return _mboard()[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>();
+    }
+
     void set_tx_rate(double rate){
-        _tx_dsp[DSP_PROP_HOST_RATE] = rate;
+        _tx_dsp()[DSP_PROP_HOST_RATE] = rate;
     }
 
     double get_tx_rate(void){
-        return _tx_dsp[DSP_PROP_HOST_RATE].as<double>();
+        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_dsp, target_freq);
+        return tune_tx_subdev_and_dsp(_tx_subdev(), _tx_dsp(), target_freq);
     }
 
     tune_result_t set_tx_freq(double target_freq, double lo_off){
-        return tune_tx_subdev_and_duc(_tx_subdev, _tx_dsp, target_freq, lo_off);
+        return tune_tx_subdev_and_dsp(_tx_subdev(), _tx_dsp(), target_freq, lo_off);
+    }
+
+    double get_tx_freq(void){
+        return derive_freq_from_tx_subdev_and_dsp(_tx_subdev(), _tx_dsp());
     }
 
     freq_range_t get_tx_freq_range(void){
-        return _tx_subdev[SUBDEV_PROP_FREQ_RANGE].as<freq_range_t>();
+        return add_dsp_shift(_tx_subdev()[SUBDEV_PROP_FREQ_RANGE].as<freq_range_t>(), _tx_dsp());
     }
 
     void set_tx_gain(float gain){
-        _tx_subdev[SUBDEV_PROP_GAIN] = gain;
+        return _tx_gain_group()->set_value(gain);
     }
 
     float get_tx_gain(void){
-        return _tx_subdev[SUBDEV_PROP_GAIN].as<float>();
+        return _tx_gain_group()->get_value();
     }
 
     gain_range_t get_tx_gain_range(void){
-        return _tx_subdev[SUBDEV_PROP_GAIN_RANGE].as<gain_range_t>();
+        return _tx_gain_group()->get_range();
     }
 
     void set_tx_antenna(const std::string &ant){
-        _tx_subdev[SUBDEV_PROP_ANTENNA] = ant;
+        _tx_subdev()[SUBDEV_PROP_ANTENNA] = ant;
     }
 
     std::string get_tx_antenna(void){
-        return _tx_subdev[SUBDEV_PROP_ANTENNA].as<std::string>();
+        return _tx_subdev()[SUBDEV_PROP_ANTENNA].as<std::string>();
     }
 
     std::vector<std::string> get_tx_antennas(void){
-        return _tx_subdev[SUBDEV_PROP_ANTENNA_NAMES].as<prop_names_t>();
+        return _tx_subdev()[SUBDEV_PROP_ANTENNA_NAMES].as<prop_names_t>();
     }
 
     bool get_tx_lo_locked(void){
-        return _tx_subdev[SUBDEV_PROP_LO_LOCKED].as<bool>();
+        return _tx_subdev()[SUBDEV_PROP_LO_LOCKED].as<bool>();
     }
 
 private:
     device::sptr _dev;
-    wax::obj _mboard;
-    wax::obj _rx_dsp;
-    wax::obj _tx_dsp;
-    wax::obj _rx_dboard;
-    wax::obj _tx_dboard;
-    wax::obj _rx_subdev;
-    wax::obj _tx_subdev;
+    wax::obj _mboard(void){
+        return (*_dev)[DEVICE_PROP_MBOARD];
+    }
+    wax::obj _rx_dsp(void){
+        return _mboard()[MBOARD_PROP_RX_DSP];
+    }
+    wax::obj _tx_dsp(void){
+        return _mboard()[MBOARD_PROP_TX_DSP];
+    }
+    wax::obj _rx_dboard(void){
+        std::string db_name = _mboard()[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>().front().db_name;
+        return _mboard()[named_prop_t(MBOARD_PROP_RX_DBOARD, db_name)];
+    }
+    wax::obj _tx_dboard(void){
+        std::string db_name = _mboard()[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>().front().db_name;
+        return _mboard()[named_prop_t(MBOARD_PROP_TX_DBOARD, db_name)];
+    }
+    wax::obj _rx_subdev(void){
+        std::string sd_name = _mboard()[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>().front().sd_name;
+        return _rx_dboard()[named_prop_t(DBOARD_PROP_SUBDEV, sd_name)];
+    }
+    wax::obj _tx_subdev(void){
+        std::string sd_name = _mboard()[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>().front().sd_name;
+        return _tx_dboard()[named_prop_t(DBOARD_PROP_SUBDEV, sd_name)];
+    }
+    gain_group::sptr _rx_gain_group(void){
+        std::string sd_name = _mboard()[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>().front().sd_name;
+        return _rx_dboard()[named_prop_t(DBOARD_PROP_GAIN_GROUP, sd_name)].as<gain_group::sptr>();
+    }
+    gain_group::sptr _tx_gain_group(void){
+        std::string sd_name = _mboard()[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>().front().sd_name;
+        return _tx_dboard()[named_prop_t(DBOARD_PROP_GAIN_GROUP, sd_name)].as<gain_group::sptr>();
+    }
 };
 
 /***********************************************************************
diff --git a/host/lib/usrp/subdev_spec.cpp b/host/lib/usrp/subdev_spec.cpp
new file mode 100644
index 000000000..0f00e2f74
--- /dev/null
+++ b/host/lib/usrp/subdev_spec.cpp
@@ -0,0 +1,77 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/subdev_spec.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/format.hpp>
+#include <boost/foreach.hpp>
+#include <stdexcept>
+#include <sstream>
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+subdev_spec_pair_t::subdev_spec_pair_t(
+    const std::string &db_name, const std::string &sd_name
+):
+    db_name(db_name),
+    sd_name(sd_name)
+{
+    /* NOP */
+}
+
+subdev_spec_t::subdev_spec_t(const std::string &markup){
+    std::vector<std::string> pairs;
+    boost::split(pairs, markup, boost::is_any_of("\t "));
+    BOOST_FOREACH(const std::string &pair, pairs){
+        if (pair == "") continue;
+        std::vector<std::string> db_sd;
+        boost::split(db_sd, pair, boost::is_any_of(":"));
+        switch(db_sd.size()){
+        case 1: this->push_back(subdev_spec_pair_t("", db_sd.front())); break;
+        case 2: this->push_back(subdev_spec_pair_t(db_sd.front(), db_sd.back())); break;
+        default: throw std::runtime_error("invalid subdev-spec markup string: "+markup);
+        }
+    }
+}
+
+std::string subdev_spec_t::to_pp_string(void) const{
+    if (this->size() == 0) return "Empty Subdevice Specification";
+
+    std::stringstream ss;
+    size_t count = 0;
+    ss << "Subdevice Specification:" << std::endl;
+    BOOST_FOREACH(const subdev_spec_pair_t &pair, *this){
+        std::string db_name = pair.db_name;
+        if (db_name == "") db_name = "0";
+        std::string sd_name = pair.sd_name;
+        if (sd_name == "") sd_name = "0";
+        ss << boost::format(
+            "    Channel %d: Daughterboard %s, Subdevice %s"
+        ) % (count++) % db_name % sd_name << std::endl;
+    }
+    return ss.str();
+}
+
+std::string subdev_spec_t::to_string(void) const{
+    std::string markup;
+    size_t count = 0;
+    BOOST_FOREACH(const subdev_spec_pair_t &pair, *this){
+        markup += ((count++)? " " : "") + pair.db_name + ":" + pair.sd_name;
+    }
+    return markup;
+}
diff --git a/host/lib/usrp/tune_helper.cpp b/host/lib/usrp/tune_helper.cpp
index 082c39f6d..e516477d3 100644
--- a/host/lib/usrp/tune_helper.cpp
+++ b/host/lib/usrp/tune_helper.cpp
@@ -16,25 +16,24 @@
 //
 
 #include <uhd/usrp/tune_helper.hpp>
-#include <uhd/utils/algorithm.hpp>
 #include <uhd/usrp/subdev_props.hpp>
 #include <uhd/usrp/dsp_props.hpp>
+#include <uhd/usrp/dboard_iface.hpp> //unit_t
+#include <boost/math/special_functions/sign.hpp>
 #include <cmath>
 
 using namespace uhd;
 using namespace uhd::usrp;
 
 /***********************************************************************
- * Tune Helper Function
+ * Tune Helper Functions
  **********************************************************************/
 static tune_result_t tune_xx_subdev_and_dxc(
-    bool is_tx,
+    dboard_iface::unit_t unit,
     wax::obj subdev, wax::obj dxc,
     double target_freq, double lo_offset
 ){
     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[DSP_PROP_FREQ_SHIFT];
     double dxc_sample_rate = dxc[DSP_PROP_CODEC_RATE].as<double>();
 
@@ -43,55 +42,52 @@ static tune_result_t tune_xx_subdev_and_dxc(
     subdev_freq_proxy = target_inter_freq;
     double actual_inter_freq = subdev_freq_proxy.as<double>();
 
-    // Calculate the DDC setting that will downconvert the baseband from the
-    // daughterboard to our target frequency.
-    double delta_freq = target_freq - actual_inter_freq;
-    int delta_sign = std::signum(delta_freq);
-    delta_freq *= delta_sign;
-    delta_freq = std::fmod(delta_freq, dxc_sample_rate);
-    bool inverted = delta_freq > dxc_sample_rate/2.0;
-    double target_dxc_freq = inverted? (delta_freq - dxc_sample_rate) : (-delta_freq);
-    target_dxc_freq *= delta_sign;
-
-    // If the spectrum is inverted, and the daughterboard doesn't do
-    // quadrature downconversion, we can fix the inversion by flipping the
-    // sign of the dxc_freq...  (This only happens using the basic_rx board)
-    if (subdev_spectrum_inverted){
-        inverted = not inverted;
-    }
-    if (inverted and not subdev_quadrature){
-        target_dxc_freq *= -1.0;
-        inverted = not inverted;
-    }
-    // down conversion versus up conversion, fight!
-    // your mother is ugly and your going down...
-    target_dxc_freq *= (is_tx)? -1.0 : +1.0;
+    //perform the correction correction for dxc rates outside of nyquist
+    double delta_freq = std::fmod(target_freq - actual_inter_freq, dxc_sample_rate);
+    bool outside_of_nyquist = std::abs(delta_freq) > dxc_sample_rate/2.0;
+    double target_dxc_freq = (outside_of_nyquist)?
+        boost::math::sign(delta_freq)*dxc_sample_rate - delta_freq : -delta_freq;
+
+    //invert the sign on the dxc freq given the following conditions
+    if (unit == dboard_iface::UNIT_TX) target_dxc_freq *= -1.0;
 
     dxc_freq_proxy = target_dxc_freq;
     double actual_dxc_freq = dxc_freq_proxy.as<double>();
 
-    //return some kind of tune result tuple/struct
+    //load and return the tune result
     tune_result_t tune_result;
     tune_result.target_inter_freq = target_inter_freq;
     tune_result.actual_inter_freq = actual_inter_freq;
     tune_result.target_dsp_freq = target_dxc_freq;
     tune_result.actual_dsp_freq = actual_dxc_freq;
-    tune_result.spectrum_inverted = inverted;
     return tune_result;
 }
 
+static double derive_freq_from_xx_subdev_and_dxc(
+    dboard_iface::unit_t unit,
+    wax::obj subdev, wax::obj dxc
+){
+    //extract actual dsp and IF frequencies
+    double actual_inter_freq = subdev[SUBDEV_PROP_FREQ].as<double>();
+    double actual_dxc_freq = dxc[DSP_PROP_FREQ_SHIFT].as<double>();
+
+    //invert the sign on the dxc freq given the following conditions
+    if (unit == dboard_iface::UNIT_TX) actual_dxc_freq *= -1.0;
+
+    return actual_inter_freq - actual_dxc_freq;
+}
+
 /***********************************************************************
  * RX Tune
  **********************************************************************/
-tune_result_t uhd::usrp::tune_rx_subdev_and_ddc(
+tune_result_t usrp::tune_rx_subdev_and_dsp(
     wax::obj subdev, wax::obj ddc,
     double target_freq, double lo_offset
 ){
-    bool is_tx = false;
-    return tune_xx_subdev_and_dxc(is_tx, subdev, ddc, target_freq, lo_offset);
+    return tune_xx_subdev_and_dxc(dboard_iface::UNIT_RX, subdev, ddc, target_freq, lo_offset);
 }
 
-tune_result_t uhd::usrp::tune_rx_subdev_and_ddc(
+tune_result_t usrp::tune_rx_subdev_and_dsp(
     wax::obj subdev, wax::obj ddc,
     double target_freq
 ){
@@ -100,21 +96,24 @@ tune_result_t uhd::usrp::tune_rx_subdev_and_ddc(
     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);
+    return tune_rx_subdev_and_dsp(subdev, ddc, target_freq, lo_offset);
+}
+
+double usrp::derive_freq_from_rx_subdev_and_dsp(wax::obj subdev, wax::obj ddc){
+    return derive_freq_from_xx_subdev_and_dxc(dboard_iface::UNIT_RX, subdev, ddc);
 }
 
 /***********************************************************************
  * TX Tune
  **********************************************************************/
-tune_result_t uhd::usrp::tune_tx_subdev_and_duc(
+tune_result_t usrp::tune_tx_subdev_and_dsp(
     wax::obj subdev, wax::obj duc,
     double target_freq, double lo_offset
 ){
-    bool is_tx = true;
-    return tune_xx_subdev_and_dxc(is_tx, subdev, duc, target_freq, lo_offset);
+    return tune_xx_subdev_and_dxc(dboard_iface::UNIT_TX, subdev, duc, target_freq, lo_offset);
 }
 
-tune_result_t uhd::usrp::tune_tx_subdev_and_duc(
+tune_result_t usrp::tune_tx_subdev_and_dsp(
     wax::obj subdev, wax::obj duc,
     double target_freq
 ){
@@ -123,5 +122,9 @@ tune_result_t uhd::usrp::tune_tx_subdev_and_duc(
     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);
+    return tune_tx_subdev_and_dsp(subdev, duc, target_freq, lo_offset);
+}
+
+double usrp::derive_freq_from_tx_subdev_and_dsp(wax::obj subdev, wax::obj duc){
+    return derive_freq_from_xx_subdev_and_dxc(dboard_iface::UNIT_TX, subdev, duc);
 }
diff --git a/host/lib/usrp/usrp2/CMakeLists.txt b/host/lib/usrp/usrp2/CMakeLists.txt
index 99d0b8bdd..796126d07 100644
--- a/host/lib/usrp/usrp2/CMakeLists.txt
+++ b/host/lib/usrp/usrp2/CMakeLists.txt
@@ -22,6 +22,7 @@ LIBUHD_APPEND_SOURCES(
     ${CMAKE_SOURCE_DIR}/lib/usrp/usrp2/clock_ctrl.hpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/usrp2/codec_ctrl.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/usrp2/codec_ctrl.hpp
+    ${CMAKE_SOURCE_DIR}/lib/usrp/usrp2/codec_impl.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/usrp2/dboard_impl.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/usrp2/dboard_iface.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/usrp2/dsp_impl.cpp
diff --git a/host/lib/usrp/usrp2/clock_ctrl.cpp b/host/lib/usrp/usrp2/clock_ctrl.cpp
index b9be037c0..02227afad 100644
--- a/host/lib/usrp/usrp2/clock_ctrl.cpp
+++ b/host/lib/usrp/usrp2/clock_ctrl.cpp
@@ -86,7 +86,7 @@ public:
 
     void set_rate_rx_dboard_clock(double rate){
         assert_has(get_rates_rx_dboard_clock(), rate, "rx dboard clock rate");
-        size_t divider = size_t(rate/get_master_clock_rate());
+        size_t divider = size_t(get_master_clock_rate()/rate);
         //bypass when the divider ratio is one
         _ad9510_regs.bypass_divider_out7 = (divider == 1)? 1 : 0;
         //calculate the low and high dividers
@@ -118,7 +118,7 @@ public:
 
     void set_rate_tx_dboard_clock(double rate){
         assert_has(get_rates_tx_dboard_clock(), rate, "tx dboard clock rate");
-        size_t divider = size_t(rate/get_master_clock_rate());
+        size_t divider = size_t(get_master_clock_rate()/rate);
         //bypass when the divider ratio is one
         _ad9510_regs.bypass_divider_out6 = (divider == 1)? 1 : 0;
         //calculate the low and high dividers
diff --git a/host/lib/usrp/usrp2/codec_impl.cpp b/host/lib/usrp/usrp2/codec_impl.cpp
new file mode 100644
index 000000000..b9d51abf5
--- /dev/null
+++ b/host/lib/usrp/usrp2/codec_impl.cpp
@@ -0,0 +1,96 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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, see <http://www.gnu.org/licenses/>.
+//
+
+#include "usrp2_impl.hpp"
+#include <uhd/usrp/codec_props.hpp>
+#include <boost/bind.hpp>
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+/***********************************************************************
+ * Helper Methods
+ **********************************************************************/
+void usrp2_mboard_impl::codec_init(void){
+    //make proxies
+    _rx_codec_proxy = wax_obj_proxy::make(
+        boost::bind(&usrp2_mboard_impl::rx_codec_get, this, _1, _2),
+        boost::bind(&usrp2_mboard_impl::rx_codec_set, this, _1, _2)
+    );
+    _tx_codec_proxy = wax_obj_proxy::make(
+        boost::bind(&usrp2_mboard_impl::tx_codec_get, this, _1, _2),
+        boost::bind(&usrp2_mboard_impl::tx_codec_set, this, _1, _2)
+    );
+}
+
+/***********************************************************************
+ * RX Codec Properties
+ **********************************************************************/
+void usrp2_mboard_impl::rx_codec_get(const wax::obj &key_, wax::obj &val){
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+
+    //handle the get request conditioned on the key
+    switch(key.as<codec_prop_t>()){
+    case CODEC_PROP_NAME:
+        val = std::string("usrp2 adc");
+        return;
+
+    case CODEC_PROP_OTHERS:
+        val = prop_names_t();
+        return;
+
+    case CODEC_PROP_GAIN_NAMES:
+        val = prop_names_t(); //no gain elements to be controlled
+        return;
+
+    default: UHD_THROW_PROP_GET_ERROR();
+    }
+}
+
+void usrp2_mboard_impl::rx_codec_set(const wax::obj &, const wax::obj &){
+    UHD_THROW_PROP_SET_ERROR();
+}
+
+/***********************************************************************
+ * TX Codec Properties
+ **********************************************************************/
+void usrp2_mboard_impl::tx_codec_get(const wax::obj &key_, wax::obj &val){
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+
+    //handle the get request conditioned on the key
+    switch(key.as<codec_prop_t>()){
+    case CODEC_PROP_NAME:
+        val = std::string("usrp2 dac - ad9777");
+        return;
+
+    case CODEC_PROP_OTHERS:
+        val = prop_names_t();
+        return;
+
+    case CODEC_PROP_GAIN_NAMES:
+        val = prop_names_t(); //no gain elements to be controlled
+        return;
+
+    default: UHD_THROW_PROP_GET_ERROR();
+    }
+}
+
+void usrp2_mboard_impl::tx_codec_set(const wax::obj &, const wax::obj &){
+    UHD_THROW_PROP_SET_ERROR();
+}
diff --git a/host/lib/usrp/usrp2/dboard_iface.cpp b/host/lib/usrp/usrp2/dboard_iface.cpp
index 6f2fb9396..1b9a4bb97 100644
--- a/host/lib/usrp/usrp2/dboard_iface.cpp
+++ b/host/lib/usrp/usrp2/dboard_iface.cpp
@@ -37,6 +37,8 @@ public:
     usrp2_dboard_iface(usrp2_iface::sptr iface, usrp2_clock_ctrl::sptr clock_ctrl);
     ~usrp2_dboard_iface(void);
 
+    std::string get_mboard_name(void){return "usrp2";}
+
     void write_aux_dac(unit_t, aux_dac_t, float);
     float read_aux_adc(unit_t, aux_adc_t);
 
diff --git a/host/lib/usrp/usrp2/dboard_impl.cpp b/host/lib/usrp/usrp2/dboard_impl.cpp
index fa8d1a674..075f22388 100644
--- a/host/lib/usrp/usrp2/dboard_impl.cpp
+++ b/host/lib/usrp/usrp2/dboard_impl.cpp
@@ -15,10 +15,10 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-
 #include "usrp2_impl.hpp"
 #include "usrp2_regs.hpp"
 #include "../dsp_utils.hpp"
+#include "../misc_utils.hpp"
 #include <uhd/usrp/subdev_props.hpp>
 #include <uhd/usrp/dboard_props.hpp>
 #include <uhd/utils/assert.hpp>
@@ -35,8 +35,8 @@ using namespace uhd::usrp;
  **********************************************************************/
 void usrp2_mboard_impl::dboard_init(void){
     //read the dboard eeprom to extract the dboard ids
-    _rx_db_eeprom = dboard_eeprom_t(_iface->read_eeprom(I2C_ADDR_RX_DB, 0, dboard_eeprom_t::num_bytes()));
-    _tx_db_eeprom = dboard_eeprom_t(_iface->read_eeprom(I2C_ADDR_TX_DB, 0, dboard_eeprom_t::num_bytes()));
+    _rx_db_eeprom = dboard_eeprom_t(_iface->read_eeprom(USRP2_I2C_ADDR_RX_DB, 0, dboard_eeprom_t::num_bytes()));
+    _tx_db_eeprom = dboard_eeprom_t(_iface->read_eeprom(USRP2_I2C_ADDR_TX_DB, 0, dboard_eeprom_t::num_bytes()));
 
     //create a new dboard interface and manager
     _dboard_iface = make_usrp2_dboard_iface(_iface, _clock_ctrl);
@@ -53,10 +53,6 @@ void usrp2_mboard_impl::dboard_init(void){
         boost::bind(&usrp2_mboard_impl::tx_dboard_get, this, _1, _2),
         boost::bind(&usrp2_mboard_impl::tx_dboard_set, this, _1, _2)
     );
-
-    //init the subdevs in use (use the first subdevice)
-    rx_dboard_set(DBOARD_PROP_USED_SUBDEVS, prop_names_t(1, _dboard_manager->get_rx_subdev_names().at(0)));
-    tx_dboard_set(DBOARD_PROP_USED_SUBDEVS, prop_names_t(1, _dboard_manager->get_tx_subdev_names().at(0)));
 }
 
 /***********************************************************************
@@ -80,10 +76,6 @@ void usrp2_mboard_impl::rx_dboard_get(const wax::obj &key_, wax::obj &val){
         val = _dboard_manager->get_rx_subdev_names();
         return;
 
-    case DBOARD_PROP_USED_SUBDEVS:
-        val = _rx_subdevs_in_use;
-        return;
-
     case DBOARD_PROP_DBOARD_ID:
         val = _rx_db_eeprom.id;
         return;
@@ -92,27 +84,26 @@ void usrp2_mboard_impl::rx_dboard_get(const wax::obj &key_, wax::obj &val){
         val = _dboard_iface;
         return;
 
+    case DBOARD_PROP_CODEC:
+        val = _rx_codec_proxy->get_link();
+        return;
+
+    case DBOARD_PROP_GAIN_GROUP:
+        val = make_gain_group(
+            _dboard_manager->get_rx_subdev(name), _rx_codec_proxy->get_link()
+        );
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
 
 void usrp2_mboard_impl::rx_dboard_set(const wax::obj &key, const wax::obj &val){
     switch(key.as<dboard_prop_t>()){
-    case DBOARD_PROP_USED_SUBDEVS:{
-            _rx_subdevs_in_use = val.as<prop_names_t>();
-            UHD_ASSERT_THROW(_rx_subdevs_in_use.size() == 1);
-            wax::obj rx_subdev = _dboard_manager->get_rx_subdev(_rx_subdevs_in_use.at(0));
-            std::cout << "Using: " << rx_subdev[SUBDEV_PROP_NAME].as<std::string>() << std::endl;
-            _iface->poke32(U2_REG_DSP_RX_MUX, dsp_type1::calc_rx_mux_word(
-                rx_subdev[SUBDEV_PROP_QUADRATURE].as<bool>(),
-                rx_subdev[SUBDEV_PROP_IQ_SWAPPED].as<bool>()
-            ));
-        }
-        return;
 
     case DBOARD_PROP_DBOARD_ID:
         _rx_db_eeprom.id = val.as<dboard_id_t>();
-        _iface->write_eeprom(I2C_ADDR_RX_DB, 0, _rx_db_eeprom.get_eeprom_bytes());
+        _iface->write_eeprom(USRP2_I2C_ADDR_RX_DB, 0, _rx_db_eeprom.get_eeprom_bytes());
         return;
 
     default: UHD_THROW_PROP_SET_ERROR();
@@ -140,10 +131,6 @@ void usrp2_mboard_impl::tx_dboard_get(const wax::obj &key_, wax::obj &val){
         val = _dboard_manager->get_tx_subdev_names();
         return;
 
-    case DBOARD_PROP_USED_SUBDEVS:
-        val = _tx_subdevs_in_use;
-        return;
-
     case DBOARD_PROP_DBOARD_ID:
         val = _tx_db_eeprom.id;
         return;
@@ -152,26 +139,26 @@ void usrp2_mboard_impl::tx_dboard_get(const wax::obj &key_, wax::obj &val){
         val = _dboard_iface;
         return;
 
+    case DBOARD_PROP_CODEC:
+        val = _tx_codec_proxy->get_link();
+        return;
+
+    case DBOARD_PROP_GAIN_GROUP:
+        val = make_gain_group(
+            _dboard_manager->get_tx_subdev(name), _tx_codec_proxy->get_link()
+        );
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
 
 void usrp2_mboard_impl::tx_dboard_set(const wax::obj &key, const wax::obj &val){
     switch(key.as<dboard_prop_t>()){
-    case DBOARD_PROP_USED_SUBDEVS:{
-            _tx_subdevs_in_use = val.as<prop_names_t>();
-            UHD_ASSERT_THROW(_tx_subdevs_in_use.size() == 1);
-            wax::obj tx_subdev = _dboard_manager->get_tx_subdev(_tx_subdevs_in_use.at(0));
-            std::cout << "Using: " << tx_subdev[SUBDEV_PROP_NAME].as<std::string>() << std::endl;
-            _iface->poke32(U2_REG_DSP_TX_MUX, dsp_type1::calc_tx_mux_word(
-                tx_subdev[SUBDEV_PROP_IQ_SWAPPED].as<bool>()
-            ));
-        }
-        return;
 
     case DBOARD_PROP_DBOARD_ID:
         _tx_db_eeprom.id = val.as<dboard_id_t>();
-        _iface->write_eeprom(I2C_ADDR_TX_DB, 0, _tx_db_eeprom.get_eeprom_bytes());
+        _iface->write_eeprom(USRP2_I2C_ADDR_TX_DB, 0, _tx_db_eeprom.get_eeprom_bytes());
         return;
 
     default: UHD_THROW_PROP_SET_ERROR();
diff --git a/host/lib/usrp/usrp2/fw_common.h b/host/lib/usrp/usrp2/fw_common.h
index fd728e393..a781c1a21 100644
--- a/host/lib/usrp/usrp2/fw_common.h
+++ b/host/lib/usrp/usrp2/fw_common.h
@@ -32,9 +32,9 @@ extern "C" {
     #define __stdint(type) type
 #endif
 
-//defines the protocol version in this shared header
-//increment this value when the protocol is changed
-#define USRP2_PROTO_VERSION 5
+//fpga and firmware compatibility numbers
+#define USRP2_FPGA_COMPAT_NUM 1
+#define USRP2_FW_COMPAT_NUM 5
 
 //used to differentiate control packets over data port
 #define USRP2_INVALID_VRT_HEADER 0
@@ -44,6 +44,22 @@ extern "C" {
 #define USRP2_UDP_CTRL_PORT 49152
 #define USRP2_UDP_DATA_PORT 49153
 
+////////////////////////////////////////////////////////////////////////
+// I2C addresses
+////////////////////////////////////////////////////////////////////////
+#define USRP2_I2C_DEV_EEPROM  0x50 // 24LC02[45]:  7-bits 1010xxx
+#define	USRP2_I2C_ADDR_MBOARD (USRP2_I2C_DEV_EEPROM | 0x0)
+#define	USRP2_I2C_ADDR_TX_DB  (USRP2_I2C_DEV_EEPROM | 0x4)
+#define	USRP2_I2C_ADDR_RX_DB  (USRP2_I2C_DEV_EEPROM | 0x5)
+
+////////////////////////////////////////////////////////////////////////
+// EEPROM Layout
+////////////////////////////////////////////////////////////////////////
+#define USRP2_EE_MBOARD_REV_LSB  0x00 //1 byte
+#define USRP2_EE_MBOARD_REV_MSB  0x01 //1 byte
+#define USRP2_EE_MBOARD_MAC_ADDR 0x02 //6 bytes
+#define USRP2_EE_MBOARD_IP_ADDR  0x0C //uint32, big-endian
+
 typedef enum{
     USRP2_CTRL_ID_HUH_WHAT = ' ',
     //USRP2_CTRL_ID_FOR_SURE, //TODO error condition enums
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
index 430f28390..9e29edd82 100644
--- a/host/lib/usrp/usrp2/io_impl.cpp
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -32,6 +32,8 @@ using namespace uhd::usrp;
 using namespace uhd::transport;
 namespace asio = boost::asio;
 
+static const int underflow_flags = async_metadata_t::EVENT_CODE_UNDERFLOW | async_metadata_t::EVENT_CODE_UNDERFLOW_IN_PACKET;
+
 /***********************************************************************
  * io impl details (internal to this file)
  * - pirate crew
@@ -44,7 +46,8 @@ struct usrp2_impl::io_impl{
 
     io_impl(size_t num_frames, size_t width):
         packet_handler_recv_state(width),
-        recv_pirate_booty(alignment_buffer_type::make(num_frames, width))
+        recv_pirate_booty(alignment_buffer_type::make(num_frames, width)),
+        async_msg_fifo(bounded_buffer<async_metadata_t>::make(100/*messages deep*/))
     {
         /* NOP */
     }
@@ -55,9 +58,9 @@ struct usrp2_impl::io_impl{
         recv_pirate_crew.join_all();
     }
 
-    bool get_recv_buffs(vrt_packet_handler::managed_recv_buffs_t &buffs){
+    bool get_recv_buffs(vrt_packet_handler::managed_recv_buffs_t &buffs, size_t timeout_ms){
         boost::this_thread::disable_interruption di; //disable because the wait can throw
-        return recv_pirate_booty->pop_elems_with_timed_wait(buffs, boost::posix_time::milliseconds(100));
+        return recv_pirate_booty->pop_elems_with_timed_wait(buffs, boost::posix_time::milliseconds(timeout_ms));
     }
 
     //state management for the vrt packet handler code
@@ -69,6 +72,7 @@ struct usrp2_impl::io_impl{
     boost::thread_group recv_pirate_crew;
     bool recv_pirate_crew_raiding;
     alignment_buffer_type::sptr recv_pirate_booty;
+    bounded_buffer<async_metadata_t>::sptr async_msg_fifo;
 };
 
 /***********************************************************************
@@ -93,12 +97,31 @@ void usrp2_impl::io_impl::recv_pirate_loop(
             //extract the vrt header packet info
             vrt::if_packet_info_t if_packet_info;
             if_packet_info.num_packet_words32 = buff->size()/sizeof(boost::uint32_t);
-            vrt::if_hdr_unpack_be(buff->cast<const boost::uint32_t *>(), if_packet_info);
+            const boost::uint32_t *vrt_hdr = buff->cast<const boost::uint32_t *>();
+            vrt::if_hdr_unpack_be(vrt_hdr, if_packet_info);
+
+            //handle a tx async report message
+            if (if_packet_info.sid == 1 and if_packet_info.packet_type != vrt::if_packet_info_t::PACKET_TYPE_DATA){
+
+                //fill in the async metadata
+                async_metadata_t metadata;
+                metadata.channel = index;
+                metadata.has_time_spec = if_packet_info.has_tsi and if_packet_info.has_tsf;
+                metadata.time_spec = time_spec_t(
+                    time_t(if_packet_info.tsi), size_t(if_packet_info.tsf), mboard->get_master_clock_freq()
+                );
+                metadata.event_code = vrt_packet_handler::get_context_code<async_metadata_t::event_code_t>(vrt_hdr, if_packet_info);
+
+                //print the famous U, and push the metadata into the message queue
+                if (metadata.event_code & underflow_flags) std::cerr << "U";
+                async_msg_fifo->push_with_pop_on_full(metadata);
+                continue;
+            }
 
             //handle the packet count / sequence number
             if (if_packet_info.packet_count != next_packet_seq){
                 //std::cerr << "S" << (if_packet_info.packet_count - next_packet_seq)%16;
-                std::cerr << "O"; //report overrun (drops in the kernel)
+                std::cerr << "O"; //report overflow (drops in the kernel)
             }
             next_packet_seq = (if_packet_info.packet_count+1)%16;
 
@@ -121,11 +144,13 @@ void usrp2_impl::io_impl::recv_pirate_loop(
  **********************************************************************/
 void usrp2_impl::io_init(void){
     //send a small data packet so the usrp2 knows the udp source port
-    for(size_t i = 0; i < _data_transports.size(); i++){
-        managed_send_buffer::sptr send_buff = _data_transports[i]->get_send_buff();
-        boost::uint32_t data = htonl(USRP2_INVALID_VRT_HEADER);
-        memcpy(send_buff->cast<void*>(), &data, sizeof(data));
+    BOOST_FOREACH(zero_copy_if::sptr data_transport, _data_transports){
+        managed_send_buffer::sptr send_buff = data_transport->get_send_buff();
+        static const boost::uint32_t data = htonl(USRP2_INVALID_VRT_HEADER);
+        std::memcpy(send_buff->cast<void*>(), &data, sizeof(data));
         send_buff->commit(sizeof(data));
+        //drain the recv buffers (may have junk)
+        while (data_transport->get_recv_buff().get());
     }
 
     //the number of recv frames is the number for the first transport
@@ -150,6 +175,18 @@ void usrp2_impl::io_init(void){
 }
 
 /***********************************************************************
+ * Async Data
+ **********************************************************************/
+bool usrp2_impl::recv_async_msg(
+    async_metadata_t &async_metadata, size_t timeout_ms
+){
+    boost::this_thread::disable_interruption di; //disable because the wait can throw
+    return _io_impl->async_msg_fifo->pop_with_timed_wait(
+        async_metadata, boost::posix_time::milliseconds(timeout_ms)
+    );
+}
+
+/***********************************************************************
  * Send Data
  **********************************************************************/
 bool get_send_buffs(
@@ -164,10 +201,8 @@ bool get_send_buffs(
 }
 
 size_t usrp2_impl::send(
-    const std::vector<const void *> &buffs,
-    size_t num_samps,
-    const tx_metadata_t &metadata,
-    const io_type_t &io_type,
+    const std::vector<const void *> &buffs, size_t num_samps,
+    const tx_metadata_t &metadata, const io_type_t &io_type,
     send_mode_t send_mode
 ){
     return vrt_packet_handler::send(
@@ -186,11 +221,9 @@ size_t usrp2_impl::send(
  * Receive Data
  **********************************************************************/
 size_t usrp2_impl::recv(
-    const std::vector<void *> &buffs,
-    size_t num_samps,
-    rx_metadata_t &metadata,
-    const io_type_t &io_type,
-    recv_mode_t recv_mode
+    const std::vector<void *> &buffs, size_t num_samps,
+    rx_metadata_t &metadata, const io_type_t &io_type,
+    recv_mode_t recv_mode, size_t timeout_ms
 ){
     return vrt_packet_handler::recv(
         _io_impl->packet_handler_recv_state,       //last state of the recv handler
@@ -199,6 +232,6 @@ size_t usrp2_impl::recv(
         io_type, _io_helper.get_rx_otw_type(),     //input and output types to convert
         _mboards.front()->get_master_clock_freq(), //master clock tick rate
         uhd::transport::vrt::if_hdr_unpack_be,
-        boost::bind(&usrp2_impl::io_impl::get_recv_buffs, _io_impl.get(), _1)
+        boost::bind(&usrp2_impl::io_impl::get_recv_buffs, _io_impl.get(), _1, timeout_ms)
     );
 }
diff --git a/host/lib/usrp/usrp2/mboard_impl.cpp b/host/lib/usrp/usrp2/mboard_impl.cpp
index 7518d3114..610aade14 100644
--- a/host/lib/usrp/usrp2/mboard_impl.cpp
+++ b/host/lib/usrp/usrp2/mboard_impl.cpp
@@ -45,8 +45,8 @@ usrp2_mboard_impl::usrp2_mboard_impl(
     _iface = usrp2_iface::make(ctrl_transport);
 
     //extract the mboard rev numbers
-    _rev_lo = _iface->read_eeprom(I2C_ADDR_MBOARD, EE_MBOARD_REV_LSB, 1).at(0);
-    _rev_hi = _iface->read_eeprom(I2C_ADDR_MBOARD, EE_MBOARD_REV_MSB, 1).at(0);
+    _rev_lo = _iface->read_eeprom(USRP2_I2C_ADDR_MBOARD, USRP2_EE_MBOARD_REV_LSB, 1).at(0);
+    _rev_hi = _iface->read_eeprom(USRP2_I2C_ADDR_MBOARD, USRP2_EE_MBOARD_REV_MSB, 1).at(0);
 
     //contruct the interfaces to mboard perifs
     _clock_ctrl = usrp2_clock_ctrl::make(_iface);
@@ -67,7 +67,7 @@ usrp2_mboard_impl::usrp2_mboard_impl(
         _allowed_decim_and_interp_rates.push_back(i);
     }
 
-    //setup the vrt rx registers
+    //init the rx control registers
     _iface->poke32(U2_REG_RX_CTRL_NSAMPS_PER_PKT, _io_helper.get_max_recv_samps_per_packet());
     _iface->poke32(U2_REG_RX_CTRL_NCHANNELS, 1);
     _iface->poke32(U2_REG_RX_CTRL_CLEAR_OVERRUN, 1); //reset
@@ -81,6 +81,12 @@ usrp2_mboard_impl::usrp2_mboard_impl(
     _iface->poke32(U2_REG_RX_CTRL_VRT_TRAILER, 0);
     _iface->poke32(U2_REG_TIME64_TPS, size_t(get_master_clock_freq()));
 
+    //init the tx control registers
+    _iface->poke32(U2_REG_TX_CTRL_NUM_CHAN, 0);    //1 channel
+    _iface->poke32(U2_REG_TX_CTRL_CLEAR_STATE, 1); //reset
+    _iface->poke32(U2_REG_TX_CTRL_REPORT_SID, 1);  //sid 1 (different from rx)
+    _iface->poke32(U2_REG_TX_CTRL_POLICY, U2_FLAG_TX_CTRL_POLICY_NEXT_PACKET);
+
     //init the ddc
     init_ddc_config();
 
@@ -90,8 +96,20 @@ usrp2_mboard_impl::usrp2_mboard_impl(
     //initialize the clock configuration
     init_clock_config();
 
+    //init the codec before the dboard
+    codec_init();
+
     //init the tx and rx dboards (do last)
     dboard_init();
+
+    //set default subdev specs
+    (*this)[MBOARD_PROP_RX_SUBDEV_SPEC] = subdev_spec_t();
+    (*this)[MBOARD_PROP_TX_SUBDEV_SPEC] = subdev_spec_t();
+
+    //Issue a stop streaming command (in case it was left running).
+    //Since this command is issued before the networking is setup,
+    //most if not all junk packets will never make it to the socket.
+    this->issue_ddc_stream_cmd(stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
 }
 
 usrp2_mboard_impl::~usrp2_mboard_impl(void){
@@ -174,14 +192,14 @@ void usrp2_mboard_impl::get(const wax::obj &key_, wax::obj &val){
     //handle the other props
     if (key.type() == typeid(std::string)){
         if (key.as<std::string>() == "mac-addr"){
-            byte_vector_t bytes = _iface->read_eeprom(I2C_ADDR_MBOARD, EE_MBOARD_MAC_ADDR, 6);
+            byte_vector_t bytes = _iface->read_eeprom(USRP2_I2C_ADDR_MBOARD, USRP2_EE_MBOARD_MAC_ADDR, 6);
             val = mac_addr_t::from_bytes(bytes).to_string();
             return;
         }
 
         if (key.as<std::string>() == "ip-addr"){
             boost::asio::ip::address_v4::bytes_type bytes;
-            std::copy(_iface->read_eeprom(I2C_ADDR_MBOARD, EE_MBOARD_IP_ADDR, 4), bytes);
+            std::copy(_iface->read_eeprom(USRP2_I2C_ADDR_MBOARD, USRP2_EE_MBOARD_IP_ADDR, 4), bytes);
             val = boost::asio::ip::address_v4(bytes).to_string();
             return;
         }
@@ -252,6 +270,14 @@ void usrp2_mboard_impl::get(const wax::obj &key_, wax::obj &val){
         }
         return;
 
+    case MBOARD_PROP_RX_SUBDEV_SPEC:
+        val = _rx_subdev_spec;
+        return;
+
+    case MBOARD_PROP_TX_SUBDEV_SPEC:
+        val = _tx_subdev_spec;
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -264,14 +290,14 @@ void usrp2_mboard_impl::set(const wax::obj &key, const wax::obj &val){
     if (key.type() == typeid(std::string)){
         if (key.as<std::string>() == "mac-addr"){
             byte_vector_t bytes = mac_addr_t::from_string(val.as<std::string>()).to_bytes();
-            _iface->write_eeprom(I2C_ADDR_MBOARD, EE_MBOARD_MAC_ADDR, bytes);
+            _iface->write_eeprom(USRP2_I2C_ADDR_MBOARD, USRP2_EE_MBOARD_MAC_ADDR, bytes);
             return;
         }
 
         if (key.as<std::string>() == "ip-addr"){
             byte_vector_t bytes(4);
             std::copy(boost::asio::ip::address_v4::from_string(val.as<std::string>()).to_bytes(), bytes);
-            _iface->write_eeprom(I2C_ADDR_MBOARD, EE_MBOARD_IP_ADDR, bytes);
+            _iface->write_eeprom(USRP2_I2C_ADDR_MBOARD, USRP2_EE_MBOARD_IP_ADDR, bytes);
             return;
         }
     }
@@ -296,6 +322,38 @@ void usrp2_mboard_impl::set(const wax::obj &key, const wax::obj &val){
         issue_ddc_stream_cmd(val.as<stream_cmd_t>());
         return;
 
+    case MBOARD_PROP_RX_SUBDEV_SPEC:
+        _rx_subdev_spec = val.as<subdev_spec_t>();
+        //handle automatic
+        if (_rx_subdev_spec.empty()) _rx_subdev_spec.push_back(
+            subdev_spec_pair_t("", _dboard_manager->get_rx_subdev_names().front())
+        );
+        //sanity check
+        UHD_ASSERT_THROW(_rx_subdev_spec.size() == 1);
+        uhd::assert_has((*this)[MBOARD_PROP_RX_DBOARD_NAMES].as<prop_names_t>(), _rx_subdev_spec.front().db_name, "rx dboard names");
+        uhd::assert_has(_dboard_manager->get_rx_subdev_names(), _rx_subdev_spec.front().sd_name, "rx subdev names");
+        //set the mux
+        _iface->poke32(U2_REG_DSP_RX_MUX, dsp_type1::calc_rx_mux_word(
+            _dboard_manager->get_rx_subdev(_rx_subdev_spec.front().sd_name)[SUBDEV_PROP_CONNECTION].as<subdev_conn_t>()
+        ));
+        return;
+
+    case MBOARD_PROP_TX_SUBDEV_SPEC:
+        _tx_subdev_spec = val.as<subdev_spec_t>();
+        //handle automatic
+        if (_tx_subdev_spec.empty()) _tx_subdev_spec.push_back(
+            subdev_spec_pair_t("", _dboard_manager->get_tx_subdev_names().front())
+        );
+        //sanity check
+        UHD_ASSERT_THROW(_tx_subdev_spec.size() == 1);
+        uhd::assert_has((*this)[MBOARD_PROP_TX_DBOARD_NAMES].as<prop_names_t>(), _tx_subdev_spec.front().db_name, "tx dboard names");
+        uhd::assert_has(_dboard_manager->get_tx_subdev_names(), _tx_subdev_spec.front().sd_name, "tx subdev names");
+        //set the mux
+        _iface->poke32(U2_REG_DSP_TX_MUX, dsp_type1::calc_tx_mux_word(
+            _dboard_manager->get_tx_subdev(_tx_subdev_spec.front().sd_name)[SUBDEV_PROP_CONNECTION].as<subdev_conn_t>()
+        ));
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
diff --git a/host/lib/usrp/usrp2/usrp2_iface.cpp b/host/lib/usrp/usrp2/usrp2_iface.cpp
index eaaa722ac..4124221ef 100644
--- a/host/lib/usrp/usrp2/usrp2_iface.cpp
+++ b/host/lib/usrp/usrp2/usrp2_iface.cpp
@@ -15,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
+#include "usrp2_regs.hpp"
 #include "usrp2_iface.hpp"
 #include <uhd/utils/assert.hpp>
 #include <uhd/types/dict.hpp>
@@ -22,12 +23,25 @@
 #include <boost/foreach.hpp>
 #include <boost/asio.hpp> //used for htonl and ntohl
 #include <boost/assign/list_of.hpp>
+#include <boost/format.hpp>
 #include <stdexcept>
 #include <algorithm>
 
 using namespace uhd;
 using namespace uhd::transport;
 
+/*!
+ * FIXME: large timeout, ethernet pause frames...
+ *
+ * Use a large timeout to work-around the fact that
+ * flow-control may throttle outgoing control packets
+ * due to its use of ethernet pause frames.
+ *
+ * This will be fixed when host-based flow control is implemented,
+ * along with larger incoming send buffers using the on-board SRAM.
+ */
+static const size_t CONTROL_TIMEOUT_MS = 3000; //3 seconds
+
 class usrp2_iface_impl : public usrp2_iface{
 public:
 /***********************************************************************
@@ -35,6 +49,15 @@ public:
  **********************************************************************/
     usrp2_iface_impl(udp_simple::sptr ctrl_transport){
         _ctrl_transport = ctrl_transport;
+
+         //check the fpga compatibility number
+        const boost::uint32_t fpga_compat_num = this->peek32(U2_REG_COMPAT_NUM_RB);
+        if (fpga_compat_num != USRP2_FPGA_COMPAT_NUM){
+            throw std::runtime_error(str(boost::format(
+                "Expected fpga compatibility number %d, but got %d:\n"
+                "The fpga build is not compatible with the host code build."
+            ) % int(USRP2_FPGA_COMPAT_NUM) % fpga_compat_num));
+        }
     }
 
     ~usrp2_iface_impl(void){
@@ -156,7 +179,7 @@ public:
 
         //fill in the seq number and send
         usrp2_ctrl_data_t out_copy = out_data;
-        out_copy.proto_ver = htonl(USRP2_PROTO_VERSION);
+        out_copy.proto_ver = htonl(USRP2_FW_COMPAT_NUM);
         out_copy.seq = htonl(++_ctrl_seq_num);
         _ctrl_transport->send(boost::asio::buffer(&out_copy, sizeof(usrp2_ctrl_data_t)));
 
@@ -164,13 +187,12 @@ public:
         boost::uint8_t usrp2_ctrl_data_in_mem[udp_simple::mtu]; //allocate max bytes for recv
         const usrp2_ctrl_data_t *ctrl_data_in = reinterpret_cast<const usrp2_ctrl_data_t *>(usrp2_ctrl_data_in_mem);
         while(true){
-            size_t len = _ctrl_transport->recv(boost::asio::buffer(usrp2_ctrl_data_in_mem));
-            if(len >= sizeof(boost::uint32_t) and ntohl(ctrl_data_in->proto_ver) != USRP2_PROTO_VERSION){
-                throw std::runtime_error(str(
-                    boost::format("Expected protocol version %d, but got %d\n"
-                    "The firmware build does not match the host code build."
-                    ) % int(USRP2_PROTO_VERSION) % ntohl(ctrl_data_in->proto_ver)
-                ));
+            size_t len = _ctrl_transport->recv(boost::asio::buffer(usrp2_ctrl_data_in_mem), CONTROL_TIMEOUT_MS);
+            if(len >= sizeof(boost::uint32_t) and ntohl(ctrl_data_in->proto_ver) != USRP2_FW_COMPAT_NUM){
+                throw std::runtime_error(str(boost::format(
+                    "Expected protocol compatibility number %d, but got %d:\n"
+                    "The firmware build is not compatible with the host code build."
+                ) % int(USRP2_FW_COMPAT_NUM) % ntohl(ctrl_data_in->proto_ver)));
             }
             if (len >= sizeof(usrp2_ctrl_data_t) and ntohl(ctrl_data_in->seq) == _ctrl_seq_num){
                 return *ctrl_data_in;
diff --git a/host/lib/usrp/usrp2/usrp2_iface.hpp b/host/lib/usrp/usrp2/usrp2_iface.hpp
index 9cc32104e..12fd4730a 100644
--- a/host/lib/usrp/usrp2/usrp2_iface.hpp
+++ b/host/lib/usrp/usrp2/usrp2_iface.hpp
@@ -26,22 +26,6 @@
 #include <utility>
 #include "fw_common.h"
 
-////////////////////////////////////////////////////////////////////////
-// I2C addresses
-////////////////////////////////////////////////////////////////////////
-#define I2C_DEV_EEPROM  0x50 // 24LC02[45]:  7-bits 1010xxx
-#define	I2C_ADDR_MBOARD (I2C_DEV_EEPROM | 0x0)
-#define	I2C_ADDR_TX_DB  (I2C_DEV_EEPROM | 0x4)
-#define	I2C_ADDR_RX_DB  (I2C_DEV_EEPROM | 0x5)
-
-////////////////////////////////////////////////////////////////////////
-// EEPROM Layout
-////////////////////////////////////////////////////////////////////////
-#define EE_MBOARD_REV_LSB  0x00 //1 byte
-#define EE_MBOARD_REV_MSB  0x01 //1 byte
-#define EE_MBOARD_MAC_ADDR 0x02 //6 bytes
-#define EE_MBOARD_IP_ADDR  0x0C //uint32, big-endian
-
 /*!
  * The usrp2 interface class:
  * Provides a set of functions to implementation layer.
diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp
index 02f53bc69..21f411afe 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -35,6 +35,9 @@ using namespace uhd::usrp;
 using namespace uhd::transport;
 namespace asio = boost::asio;
 
+//! wait this long for a control response when discovering devices
+static const size_t DISCOVERY_TIMEOUT_MS = 100;
+
 /***********************************************************************
  * Helper Functions
  **********************************************************************/
@@ -94,7 +97,7 @@ static uhd::device_addrs_t usrp2_find(const device_addr_t &hint){
 
     //send a hello control packet
     usrp2_ctrl_data_t ctrl_data_out;
-    ctrl_data_out.proto_ver = htonl(USRP2_PROTO_VERSION);
+    ctrl_data_out.proto_ver = htonl(USRP2_FW_COMPAT_NUM);
     ctrl_data_out.id = htonl(USRP2_CTRL_ID_WAZZUP_BRO);
     udp_transport->send(boost::asio::buffer(&ctrl_data_out, sizeof(ctrl_data_out)));
 
@@ -102,7 +105,7 @@ static uhd::device_addrs_t usrp2_find(const device_addr_t &hint){
     boost::uint8_t usrp2_ctrl_data_in_mem[udp_simple::mtu]; //allocate max bytes for recv
     const usrp2_ctrl_data_t *ctrl_data_in = reinterpret_cast<const usrp2_ctrl_data_t *>(usrp2_ctrl_data_in_mem);
     while(true){
-        size_t len = udp_transport->recv(asio::buffer(usrp2_ctrl_data_in_mem));
+        size_t len = udp_transport->recv(asio::buffer(usrp2_ctrl_data_in_mem), DISCOVERY_TIMEOUT_MS);
         //std::cout << len << "\n";
         if (len > offsetof(usrp2_ctrl_data_t, data)){
             //handle the received data
diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp
index ab23830c0..157d17057 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.hpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.hpp
@@ -35,6 +35,7 @@
 #include <uhd/transport/udp_simple.hpp> //mtu
 #include <uhd/transport/udp_zero_copy.hpp>
 #include <uhd/usrp/dboard_manager.hpp>
+#include <uhd/usrp/subdev_spec.hpp>
 
 /*!
  * Make a usrp2 dboard interface.
@@ -143,6 +144,7 @@ private:
     //properties for this mboard
     void get(const wax::obj &, wax::obj &);
     void set(const wax::obj &, const wax::obj &);
+    uhd::usrp::subdev_spec_t _rx_subdev_spec, _tx_subdev_spec;
 
     //interfaces
     usrp2_iface::sptr _iface;
@@ -161,18 +163,25 @@ private:
     void update_clock_config(void);
     void set_time_spec(const uhd::time_spec_t &time_spec, bool now);
 
+    //properties interface for the codec
+    void codec_init(void);
+    void rx_codec_get(const wax::obj &, wax::obj &);
+    void rx_codec_set(const wax::obj &, const wax::obj &);
+    void tx_codec_get(const wax::obj &, wax::obj &);
+    void tx_codec_set(const wax::obj &, const wax::obj &);
+    wax_obj_proxy::sptr _rx_codec_proxy;
+    wax_obj_proxy::sptr _tx_codec_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 &);
     wax_obj_proxy::sptr _rx_dboard_proxy;
-    uhd::prop_names_t _rx_subdevs_in_use;
     uhd::usrp::dboard_eeprom_t _rx_db_eeprom;
 
     //properties interface for tx dboard
     void tx_dboard_get(const wax::obj &, wax::obj &);
     void tx_dboard_set(const wax::obj &, const wax::obj &);
     wax_obj_proxy::sptr _tx_dboard_proxy;
-    uhd::prop_names_t _tx_subdevs_in_use;
     uhd::usrp::dboard_eeprom_t _tx_db_eeprom;
 
     //methods and shadows for the ddc dsp
@@ -224,8 +233,7 @@ public:
     }
     size_t send(
         const std::vector<const void *> &, size_t,
-        const uhd::tx_metadata_t &,
-        const uhd::io_type_t &,
+        const uhd::tx_metadata_t &, const uhd::io_type_t &,
         uhd::device::send_mode_t
     );
     size_t get_max_recv_samps_per_packet(void) const{
@@ -233,10 +241,10 @@ public:
     }
     size_t recv(
         const std::vector<void *> &, size_t,
-        uhd::rx_metadata_t &,
-        const uhd::io_type_t &,
-        uhd::device::recv_mode_t
+        uhd::rx_metadata_t &, const uhd::io_type_t &,
+        uhd::device::recv_mode_t, size_t
     );
+    bool recv_async_msg(uhd::async_metadata_t &, size_t);
 
 private:
     //device properties interface
diff --git a/host/lib/usrp/usrp2/usrp2_regs.hpp b/host/lib/usrp/usrp2/usrp2_regs.hpp
index 1a5864c85..9d306090b 100644
--- a/host/lib/usrp/usrp2/usrp2_regs.hpp
+++ b/host/lib/usrp/usrp2/usrp2_regs.hpp
@@ -107,6 +107,7 @@
 
 #define U2_REG_TIME64_SECS_RB  (0xCC00 + 4*10)
 #define U2_REG_TIME64_TICKS_RB (0xCC00 + 4*11)
+#define U2_REG_COMPAT_NUM_RB   (0xCC00 + 4*12)
 
 //pps flags (see above)
 #define U2_FLAG_TIME64_PPS_NEGEDGE (0 << 0)
@@ -226,7 +227,7 @@
 #define U2_REG_ATR_FULL_RXSIDE  U2_REG_ATR_BASE + 14
 
 ///////////////////////////////////////////////////
-// VITA RX CTRL regs
+// RX CTRL regs
 ///////////////////////////////////////////////////
 // The following 3 are logically a single command register.
 // They are clocked into the underlying fifo when time_ticks is written.
@@ -241,4 +242,16 @@
 #define U2_REG_RX_CTRL_NSAMPS_PER_PKT    _SR_ADDR(SR_RX_CTRL + 7)
 #define U2_REG_RX_CTRL_NCHANNELS         _SR_ADDR(SR_RX_CTRL + 8) // 1 in basic case, up to 4 for vector sources
 
+///////////////////////////////////////////////////
+// TX CTRL regs
+///////////////////////////////////////////////////
+#define U2_REG_TX_CTRL_NUM_CHAN          _SR_ADDR(SR_TX_CTRL + 0)
+#define U2_REG_TX_CTRL_CLEAR_STATE       _SR_ADDR(SR_TX_CTRL + 1)
+#define U2_REG_TX_CTRL_REPORT_SID        _SR_ADDR(SR_TX_CTRL + 2)
+#define U2_REG_TX_CTRL_POLICY            _SR_ADDR(SR_TX_CTRL + 3)
+
+#define U2_FLAG_TX_CTRL_POLICY_WAIT          (0x1 << 0)
+#define U2_FLAG_TX_CTRL_POLICY_NEXT_PACKET   (0x1 << 1)
+#define U2_FLAG_TX_CTRL_POLICY_NEXT_BURST    (0x1 << 2)
+
 #endif /* INCLUDED_USRP2_REGS_HPP */
diff --git a/host/lib/usrp/usrp_e/CMakeLists.txt b/host/lib/usrp/usrp_e/CMakeLists.txt
index db6d162d4..1d64d29d2 100644
--- a/host/lib/usrp/usrp_e/CMakeLists.txt
+++ b/host/lib/usrp/usrp_e/CMakeLists.txt
@@ -18,27 +18,14 @@
 #This file will be included by cmake, use absolute paths!
 
 ########################################################################
-# Helpful macro to check for required headers
-########################################################################
-INCLUDE(CheckIncludeFileCXX)
-SET(HAVE_USRP_E_REQUIRED_HEADERS TRUE)
-MACRO(USRP_E_REQUIRE_HEADER header variable)
-    CHECK_INCLUDE_FILE_CXX(${header} ${variable})
-    IF(NOT ${variable})
-        SET(HAVE_USRP_E_REQUIRED_HEADERS FALSE)
-    ENDIF(NOT ${variable})
-ENDMACRO(USRP_E_REQUIRE_HEADER)
-
-########################################################################
 # Conditionally configure the USRP-E support
 ########################################################################
 MESSAGE(STATUS "Configuring usrp-e support...")
 
-USRP_E_REQUIRE_HEADER(linux/ioctl.h      HAVE_LINUX_IOCTL_H)
-USRP_E_REQUIRE_HEADER(linux/spi/spidev.h HAVE_LINUX_SPI_SPIDEV_H)
-USRP_E_REQUIRE_HEADER(linux/usrp_e.h     HAVE_LINUX_USRP_E_H)
+INCLUDE(CheckIncludeFileCXX)
+CHECK_INCLUDE_FILE_CXX(linux/usrp_e.h HAVE_LINUX_USRP_E_H)
 
-IF(HAVE_USRP_E_REQUIRED_HEADERS)
+IF(HAVE_LINUX_USRP_E_H)
     MESSAGE(STATUS "  Building usrp-e support.")
     LIBUHD_APPEND_SOURCES(
         ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e/clock_ctrl.cpp
@@ -57,6 +44,6 @@ IF(HAVE_USRP_E_REQUIRED_HEADERS)
         ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e/usrp_e_iface.hpp
         ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e/usrp_e_regs.hpp
     )
-ELSE(HAVE_USRP_E_REQUIRED_HEADERS)
+ELSE(HAVE_LINUX_USRP_E_H)
     MESSAGE(STATUS "  Skipping usrp-e support.")
-ENDIF(HAVE_USRP_E_REQUIRED_HEADERS)
+ENDIF(HAVE_LINUX_USRP_E_H)