Port of daughterboards from wax to new property trees

    Ported:
    Basic/LF
    Unknown
    XCVR
    DBSRX
    DBSRX2
    TVRX
    TVRX2

9 files changed, 572 insertions, 1249 deletions

diff --git a/host/lib/usrp/dboard/CMakeLists.txt b/host/lib/usrp/dboard/CMakeLists.txt
index adaaab683..cb71e695b 100644
--- a/host/lib/usrp/dboard/CMakeLists.txt
+++ b/host/lib/usrp/dboard/CMakeLists.txt
@@ -20,16 +20,16 @@
 ########################################################################
 
 LIBUHD_APPEND_SOURCES(
-    #${CMAKE_CURRENT_SOURCE_DIR}/db_basic_and_lf.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/db_basic_and_lf.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/db_rfx.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/db_xcvr2450.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/db_xcvr2450.cpp
     #${CMAKE_CURRENT_SOURCE_DIR}/db_sbx.cpp
     #${CMAKE_CURRENT_SOURCE_DIR}/db_wbx_common.cpp
     #${CMAKE_CURRENT_SOURCE_DIR}/db_wbx_simple.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/db_dbsrx.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/db_unknown.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/db_tvrx.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/db_dbsrx2.cpp
-    #${CMAKE_CURRENT_SOURCE_DIR}/db_tvrx2.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/db_dbsrx.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/db_unknown.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/db_tvrx.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/db_dbsrx2.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/db_tvrx2.cpp
 )
 
diff --git a/host/lib/usrp/dboard/db_basic_and_lf.cpp b/host/lib/usrp/dboard/db_basic_and_lf.cpp
index 86d86dda0..971ecaeda 100644
--- a/host/lib/usrp/dboard/db_basic_and_lf.cpp
+++ b/host/lib/usrp/dboard/db_basic_and_lf.cpp
@@ -23,6 +23,7 @@
 #include <uhd/usrp/dboard_base.hpp>
 #include <uhd/usrp/dboard_manager.hpp>
 #include <boost/assign/list_of.hpp>
+#include <boost/bind.hpp>
 #include <boost/format.hpp>
 
 using namespace uhd;
@@ -48,9 +49,6 @@ public:
     basic_rx(ctor_args_t args, double max_freq);
     ~basic_rx(void);
 
-    void rx_get(const wax::obj &key, wax::obj &val);
-    void rx_set(const wax::obj &key, const wax::obj &val);
-
 private:
     double _max_freq;
 };
@@ -60,18 +58,15 @@ public:
     basic_tx(ctor_args_t args, double max_freq);
     ~basic_tx(void);
 
-    void tx_get(const wax::obj &key, wax::obj &val);
-    void tx_set(const wax::obj &key, const wax::obj &val);
-
 private:
     double _max_freq;
 };
 
-static const uhd::dict<std::string, subdev_conn_t> sd_name_to_conn = map_list_of
-    ("AB", SUBDEV_CONN_COMPLEX_IQ)
-    ("BA", SUBDEV_CONN_COMPLEX_QI)
-    ("A",  SUBDEV_CONN_REAL_I)
-    ("B",  SUBDEV_CONN_REAL_Q)
+static const uhd::dict<std::string, std::string> sd_name_to_conn = map_list_of
+    ("AB", "IQ")
+    ("BA", "QI")
+    ("A",  "I")
+    ("B",  "Q")
 ;
 
 /***********************************************************************
@@ -105,222 +100,95 @@ UHD_STATIC_BLOCK(reg_basic_and_lf_dboards){
  **********************************************************************/
 basic_rx::basic_rx(ctor_args_t args, double max_freq) : rx_dboard_base(args){
     _max_freq = max_freq;
+    //this->get_iface()->set_clock_enabled(dboard_iface::UNIT_RX, true);
     
+    ////////////////////////////////////////////////////////////////////
+    // Register properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_rx_subtree()->create<std::string>("name").set(
+        std::string(str(boost::format("%s - %s")
+            % get_rx_id().to_pp_string()
+            % get_subdev_name()
+        )));
+    this->get_rx_subtree()->create<int>("gains"); //phony property so this dir exists
+    this->get_rx_subtree()->create<double>("freq/value")
+        .set(double(0.0));
+    this->get_rx_subtree()->create<meta_range_t>("freq/range")
+        .set(freq_range_t(-_max_freq, +_max_freq));
+    this->get_rx_subtree()->create<std::string>("antenna/value")
+        .set("");
+    this->get_rx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(list_of(""));
+    this->get_rx_subtree()->create<int>("sensors"); //phony property so this dir exists
+    this->get_rx_subtree()->create<std::string>("connection")
+        .set(sd_name_to_conn[get_subdev_name()]);
+    this->get_rx_subtree()->create<bool>("enabled")
+        .set(true); //always enabled
+    this->get_rx_subtree()->create<bool>("use_lo_offset")
+        .set(false);
+    this->get_rx_subtree()->create<double>("bandwidth/value")
+        .set(subdev_bandwidth_scalar[get_subdev_name()]*_max_freq);
+    this->get_rx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(freq_range_t(subdev_bandwidth_scalar[get_subdev_name()]*_max_freq, subdev_bandwidth_scalar[get_subdev_name()]*_max_freq));
+    
+    //enable RX dboard clock
+    this->get_iface()->set_clock_enabled(dboard_iface::UNIT_RX, true);
+
     //set GPIOs to output 0x0000 to decrease noise pickup
     this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_RX, 0x0000);
     this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, 0xFFFF);
     this->get_iface()->set_gpio_out(dboard_iface::UNIT_RX, 0x0000);
-    //this->get_iface()->set_clock_enabled(dboard_iface::UNIT_RX, true);
 }
 
 basic_rx::~basic_rx(void){
     /* NOP */
 }
 
-void basic_rx::rx_get(const wax::obj &key_, wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-    case SUBDEV_PROP_NAME:
-        val = std::string(str(boost::format("%s - %s")
-            % get_rx_id().to_pp_string()
-            % get_subdev_name()
-        ));
-        return;
-
-    case SUBDEV_PROP_OTHERS:
-        val = prop_names_t(); //empty
-        return;
-
-    case SUBDEV_PROP_GAIN:
-        val = double(0);
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        val = gain_range_t(0, 0, 0);
-        return;
-
-    case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(); //empty
-        return;
-
-    case SUBDEV_PROP_FREQ:
-        val = double(0);
-        return;
-
-    case SUBDEV_PROP_FREQ_RANGE:
-        val = freq_range_t(-_max_freq, +_max_freq);
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        val = std::string("");
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = prop_names_t(1, ""); //vector of 1 empty string
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:
-        val = std::vector<std::string>(); //empty
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = sd_name_to_conn[get_subdev_name()];
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        val = true; //always enabled
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        val = subdev_bandwidth_scalar[get_subdev_name()]*_max_freq;
-        return;
-
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
-}
-
-void basic_rx::rx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-
-    case SUBDEV_PROP_GAIN:
-        UHD_ASSERT_THROW(val.as<double>() == double(0));
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        if (val.as<std::string>().empty()) return;
-        throw uhd::value_error("no selectable antennas on this board");
-
-    case SUBDEV_PROP_FREQ:
-        return; // it wont do you much good, but you can set it
-
-    case SUBDEV_PROP_ENABLED:
-        return; //always enabled
-
-    case SUBDEV_PROP_BANDWIDTH:
-        UHD_MSG(warning) << boost::format(
-            "%s: No tunable bandwidth, fixed filtered to %0.2fMHz"
-        ) % get_rx_id().to_pp_string() % _max_freq;
-        return;
-
-    default: UHD_THROW_PROP_SET_ERROR();
-    }
-}
-
 /***********************************************************************
  * Basic and LF TX dboard
  **********************************************************************/
 basic_tx::basic_tx(ctor_args_t args, double max_freq) : tx_dboard_base(args){
     _max_freq = max_freq;
     //this->get_iface()->set_clock_enabled(dboard_iface::UNIT_TX, true);
-}
 
-basic_tx::~basic_tx(void){
-    /* NOP */
-}
-
-void basic_tx::tx_get(const wax::obj &key_, wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-    case SUBDEV_PROP_NAME:
-        val = std::string(str(boost::format("%s - %s")
-            % get_tx_id().to_pp_string()
+    ////////////////////////////////////////////////////////////////////
+    // Register properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_tx_subtree()->create<std::string>("name").set(
+        std::string(str(boost::format("%s - %s")
+            % get_rx_id().to_pp_string()
             % get_subdev_name()
-        ));
-        return;
-
-    case SUBDEV_PROP_OTHERS:
-        val = prop_names_t(); //empty
-        return;
-
-    case SUBDEV_PROP_GAIN:
-        val = double(0);
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        val = gain_range_t(0, 0, 0);
-        return;
-
-    case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(); //empty
-        return;
-
-    case SUBDEV_PROP_FREQ:
-        val = double(0);
-        return;
-
-    case SUBDEV_PROP_FREQ_RANGE:
-        val = freq_range_t(-_max_freq, +_max_freq);
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        val = std::string("");
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = prop_names_t(1, ""); //vector of 1 empty string
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:
-        val = std::vector<std::string>(); //empty
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = sd_name_to_conn[get_subdev_name()];
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        val = true; //always enabled
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        val = subdev_bandwidth_scalar[get_subdev_name()]*_max_freq;
-        return;
+        )));
+    this->get_tx_subtree()->create<int>("gains"); //phony property so this dir exists
+    this->get_tx_subtree()->create<double>("freq/value")
+        .set(double(0.0));
+    this->get_tx_subtree()->create<meta_range_t>("freq/range")
+        .set(freq_range_t(-_max_freq, +_max_freq));
+    this->get_tx_subtree()->create<std::string>("antenna/value")
+        .set("");
+    this->get_tx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(list_of(""));
+    this->get_tx_subtree()->create<int>("sensors"); //phony property so this dir exists
+    this->get_tx_subtree()->create<std::string>("connection")
+        .set(sd_name_to_conn[get_subdev_name()]);
+    this->get_tx_subtree()->create<bool>("enabled")
+        .set(true); //always enabled
+    this->get_tx_subtree()->create<bool>("use_lo_offset")
+        .set(false);
+    this->get_tx_subtree()->create<double>("bandwidth/value")
+        .set(subdev_bandwidth_scalar[get_subdev_name()]*_max_freq);
+    this->get_tx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(freq_range_t(subdev_bandwidth_scalar[get_subdev_name()]*_max_freq, subdev_bandwidth_scalar[get_subdev_name()]*_max_freq));
+    
+    //enable TX dboard clock
+    this->get_iface()->set_clock_enabled(dboard_iface::UNIT_TX, true);
 
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
+    //set GPIOs to output 0x0000 to decrease noise pickup
+    this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_TX, 0x0000);
+    this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_TX, 0xFFFF);
+    this->get_iface()->set_gpio_out(dboard_iface::UNIT_TX, 0x0000);
 }
 
-void basic_tx::tx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-
-    case SUBDEV_PROP_GAIN:
-        UHD_ASSERT_THROW(val.as<double>() == double(0));
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        if (val.as<std::string>().empty()) return;
-        throw uhd::value_error("no selectable antennas on this board");
-
-    case SUBDEV_PROP_FREQ:
-        return; // it wont do you much good, but you can set it
-
-    case SUBDEV_PROP_ENABLED:
-        return; //always enabled
-
-    case SUBDEV_PROP_BANDWIDTH:
-        UHD_MSG(warning) << boost::format(
-            "%s: No tunable bandwidth, fixed filtered to %0.2fMHz"
-        ) % get_tx_id().to_pp_string() % _max_freq;
-        return;
-
-    default: UHD_THROW_PROP_SET_ERROR();
-    }
+basic_tx::~basic_tx(void){
+    /* NOP */
 }
diff --git a/host/lib/usrp/dboard/db_dbsrx.cpp b/host/lib/usrp/dboard/db_dbsrx.cpp
index c65c52590..7a90467ef 100644
--- a/host/lib/usrp/dboard/db_dbsrx.cpp
+++ b/host/lib/usrp/dboard/db_dbsrx.cpp
@@ -46,9 +46,12 @@ using namespace boost::assign;
  **********************************************************************/
 static const freq_range_t dbsrx_freq_range(0.8e9, 2.4e9);
 
+//Multiplied by 2.0 for conversion to complex bandpass from lowpass
+static const freq_range_t dbsrx_bandwidth_range(2.0*4.0e6, 2.0*33.0e6);
+
 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 std::vector<std::string> 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))
@@ -63,9 +66,6 @@ public:
     dbsrx(ctor_args_t args);
     ~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;
     double _bandwidth;
@@ -76,9 +76,9 @@ private:
         return (this->get_iface()->get_special_props().mangle_i2c_addrs)? 0x65 : 0x67;
     };
 
-    void set_lo_freq(double target_freq);
-    void set_gain(double gain, const std::string &name);
-    void set_bandwidth(double bandwidth);
+    double set_lo_freq(double target_freq);
+    double set_gain(double gain, const std::string &name);
+    double set_bandwidth(double bandwidth);
 
     void send_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){
         start_reg = boost::uint8_t(uhd::clip(int(start_reg), 0x0, 0x5));
@@ -136,10 +136,10 @@ private:
     }
 
     /*!
-     * Is the LO locked?
-     * \return true for locked
+     * Get the lock detect status of the LO.
+     * \return sensor for locked
      */
-    bool get_locked(void){
+    sensor_value_t get_locked(void){
         read_reg(0x0, 0x0);
 
         //mask and return lock detect
@@ -149,9 +149,8 @@ private:
             "DBSRX: locked %d"
         ) % locked << std::endl;
 
-        return locked;
+        return sensor_value_t("LO", locked, "locked", "unlocked");
     }
-
 };
 
 /***********************************************************************
@@ -190,30 +189,58 @@ dbsrx::dbsrx(ctor_args_t args) : rx_dboard_base(args){
                 "Please see the daughterboard app notes" 
                 ) % this->get_rx_id().to_pp_string();
 
+    //send initial register settings
+    this->send_reg(0x0, 0x5);
+
+    //set defaults for LO, gains, and filter bandwidth
+    _bandwidth = 33e6;
+
+    ////////////////////////////////////////////////////////////////////
+    // Register properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_rx_subtree()->create<std::string>("name")
+        .set(get_rx_id().to_pp_string());
+    this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
+        .publish(boost::bind(&dbsrx::get_locked, this));
+    BOOST_FOREACH(const std::string &name, dbsrx_gain_ranges.keys()){
+        this->get_rx_subtree()->create<double>("gains/"+name+"/value")
+            .coerce(boost::bind(&dbsrx::set_gain, this, _1, name))
+            .set(dbsrx_gain_ranges[name].start());
+        this->get_rx_subtree()->create<meta_range_t>("gains/"+name+"/range")
+            .set(dbsrx_gain_ranges[name]);
+    }
+    this->get_rx_subtree()->create<double>("freq/value")
+        .coerce(boost::bind(&dbsrx::set_lo_freq, this, _1))
+        .set(dbsrx_freq_range.start());
+    this->get_rx_subtree()->create<meta_range_t>("freq/range")
+        .set(dbsrx_freq_range);
+    this->get_rx_subtree()->create<std::string>("antenna/value")
+        .set(dbsrx_antennas.at(0));
+    this->get_rx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(dbsrx_antennas);
+    this->get_rx_subtree()->create<std::string>("connection")
+        .set("IQ");
+    this->get_rx_subtree()->create<bool>("enabled")
+        .set(true); //always enabled
+    this->get_rx_subtree()->create<bool>("use_lo_offset")
+        .set(false);
+    this->get_rx_subtree()->create<double>("bandwidth/value")
+        .coerce(boost::bind(&dbsrx::set_bandwidth, this, _1))
+        .set(2.0*_bandwidth); //_bandwidth in lowpass, convert to complex bandpass
+    this->get_rx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(dbsrx_bandwidth_range);
+
     //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
     if (this->get_iface()->get_special_props().soft_clock_divider){
-        this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, 0x1); // GPIO0 is clock
+        this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, 0x1); // GPIO0 is clock when on USRP1
     }
     else{
         this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, 0x0); // All Inputs
     }
-
-    //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.start());
-
-    BOOST_FOREACH(const std::string &name, dbsrx_gain_ranges.keys()){
-        set_gain(dbsrx_gain_ranges[name].start(), name);
-    }
-
-    set_bandwidth(33e6); // default bandwidth from datasheet
 }
 
 dbsrx::~dbsrx(void){
@@ -223,7 +250,7 @@ dbsrx::~dbsrx(void){
 /***********************************************************************
  * Tuning
  **********************************************************************/
-void dbsrx::set_lo_freq(double target_freq){
+double dbsrx::set_lo_freq(double target_freq){
     target_freq = dbsrx_freq_range.clip(target_freq);
 
     double actual_freq=0.0, pfd_freq=0.0, ref_clock=0.0;
@@ -398,6 +425,8 @@ void dbsrx::set_lo_freq(double target_freq){
 
     if (update_filter_settings) set_bandwidth(_bandwidth);
     get_locked();
+
+    return _lo_freq;
 }
 
 /***********************************************************************
@@ -456,7 +485,7 @@ static double gain_to_gc1_rfvga_dac(double &gain){
     return dac_volts;
 }
 
-void dbsrx::set_gain(double gain, const std::string &name){
+double dbsrx::set_gain(double 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);
@@ -468,14 +497,19 @@ void dbsrx::set_gain(double gain, const std::string &name){
     }
     else UHD_THROW_INVALID_CODE_PATH();
     _gains[name] = gain;
+
+    return gain;
 }
 
 /***********************************************************************
  * Bandwidth Handling
  **********************************************************************/
-void dbsrx::set_bandwidth(double bandwidth){
+double dbsrx::set_bandwidth(double bandwidth){
+    //convert complex bandpass to lowpass bandwidth
+    bandwidth = bandwidth/2.0;
+
     //clip the input
-    bandwidth = uhd::clip<double>(bandwidth, 4e6, 33e6);
+    bandwidth = dbsrx_bandwidth_range.clip(bandwidth);
 
     double ref_clock = this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX);
     
@@ -492,109 +526,7 @@ void dbsrx::set_bandwidth(double bandwidth){
     ) % (_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){
-    named_prop_t key = named_prop_t::extract(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(), key.name, "dbsrx gain name");
-        val = _gains[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        assert_has(dbsrx_gain_ranges.keys(), key.name, "dbsrx gain name");
-        val = dbsrx_gain_ranges[key.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 = dbsrx_antennas.at(0);
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = dbsrx_antennas;
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = SUBDEV_CONN_COMPLEX_IQ;
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        val = true; //always enabled
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SENSOR:
-        UHD_ASSERT_THROW(key.name == "lo_locked");
-        val = sensor_value_t("LO", this->get_locked(), "locked", "unlocked");
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:
-        val = prop_names_t(1, "lo_locked");
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        val = 2*_bandwidth; //_bandwidth is low-pass, we want complex double-sided
-        return;
-
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
-}
-
-void dbsrx::rx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(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_ANTENNA:
-        assert_has(dbsrx_antennas, val.as<std::string>(), "DBSRX antenna name");
-        return;
 
-    case SUBDEV_PROP_GAIN:
-        this->set_gain(val.as<double>(), key.name);
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        return; //always enabled
-
-    case SUBDEV_PROP_BANDWIDTH:
-        this->set_bandwidth(val.as<double>()/2.0); //complex double-sided, we want low-pass
-        return;
-
-    default: UHD_THROW_PROP_SET_ERROR();
-    }
+    //convert lowpass back to complex bandpass bandwidth
+    return 2.0*_bandwidth;
 }
-
diff --git a/host/lib/usrp/dboard/db_dbsrx2.cpp b/host/lib/usrp/dboard/db_dbsrx2.cpp
index f19236907..954d7083d 100644
--- a/host/lib/usrp/dboard/db_dbsrx2.cpp
+++ b/host/lib/usrp/dboard/db_dbsrx2.cpp
@@ -42,9 +42,12 @@ using namespace boost::assign;
  **********************************************************************/
 static const freq_range_t dbsrx2_freq_range(0.8e9, 2.4e9);
 
+//Multiplied by 2.0 for conversion to complex bandpass from lowpass
+static const freq_range_t dbsrx2_bandwidth_range(2.0*4.0e6, 2.0*40.0e6);
+
 static const int dbsrx2_ref_divider = 4; // Hitachi HMC426 divider (U7)
 
-static const prop_names_t dbsrx2_antennas = list_of("J3");
+static const std::vector<std::string> dbsrx2_antennas = list_of("J3");
 
 static const uhd::dict<std::string, gain_range_t> dbsrx2_gain_ranges = map_list_of
     ("GC1", gain_range_t(0, 73, 0.05))
@@ -59,9 +62,6 @@ public:
     dbsrx2(ctor_args_t args);
     ~dbsrx2(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;
     double _bandwidth;
@@ -72,9 +72,9 @@ private:
         return (this->get_iface()->get_special_props().mangle_i2c_addrs)? 0x60 : 0x61;
     }
 
-    void set_lo_freq(double target_freq);
-    void set_gain(double gain, const std::string &name);
-    void set_bandwidth(double bandwidth);
+    double set_lo_freq(double target_freq);
+    double set_gain(double gain, const std::string &name);
+    double set_bandwidth(double bandwidth);
 
     void send_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){
         start_reg = boost::uint8_t(uhd::clip(int(start_reg), 0x0, 0xB));
@@ -146,10 +146,10 @@ private:
     }
 
     /*!
-     * Is the LO locked?
-     * \return true for locked
+     * Get the lock detect status of the LO.
+     * \return sensor for locked
      */
-    bool get_locked(void){
+    sensor_value_t get_locked(void){
         read_reg(0xC, 0xD);
 
         //mask and return lock detect
@@ -159,9 +159,8 @@ private:
             "DBSRX2 locked: %d"
         ) % locked << std::endl;
 
-        return locked;
+        return sensor_value_t("LO", locked, "locked", "unlocked");
     }
-
 };
 
 /***********************************************************************
@@ -182,28 +181,53 @@ UHD_STATIC_BLOCK(reg_dbsrx2_dboard){
  * Structors
  **********************************************************************/
 dbsrx2::dbsrx2(ctor_args_t args) : rx_dboard_base(args){
-    //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
-
     //send initial register settings
     send_reg(0x0, 0xB);
     //for (boost::uint8_t addr=0; addr<=12; addr++) this->send_reg(addr, addr);
 
-    //set defaults for LO, gains
-    set_lo_freq(dbsrx2_freq_range.start());
+    ////////////////////////////////////////////////////////////////////
+    // Register properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_rx_subtree()->create<std::string>("name")
+        .set(get_rx_id().to_pp_string());
+    this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
+        .publish(boost::bind(&dbsrx2::get_locked, this));
     BOOST_FOREACH(const std::string &name, dbsrx2_gain_ranges.keys()){
-        set_gain(dbsrx2_gain_ranges[name].start(), name);
+        this->get_rx_subtree()->create<double>("gains/"+name+"/value")
+            .coerce(boost::bind(&dbsrx2::set_gain, this, _1, name))
+            .set(dbsrx2_gain_ranges[name].start());
+        this->get_rx_subtree()->create<meta_range_t>("gains/"+name+"/range")
+            .set(dbsrx2_gain_ranges[name]);
     }
+    this->get_rx_subtree()->create<double>("freq/value")
+        .coerce(boost::bind(&dbsrx2::set_lo_freq, this, _1))
+        .set(dbsrx2_freq_range.start());
+    this->get_rx_subtree()->create<meta_range_t>("freq/range")
+        .set(dbsrx2_freq_range);
+    this->get_rx_subtree()->create<std::string>("antenna/value")
+        .set(dbsrx2_antennas.at(0));
+    this->get_rx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(dbsrx2_antennas);
+    this->get_rx_subtree()->create<std::string>("connection")
+        .set("QI");
+    this->get_rx_subtree()->create<bool>("enabled")
+        .set(true); //always enabled
+    this->get_rx_subtree()->create<bool>("use_lo_offset")
+        .set(false);
+    this->get_rx_subtree()->create<double>("bandwidth/value")
+        .coerce(boost::bind(&dbsrx2::set_bandwidth, this, _1))
+        .set(2.0*40.0e6); //bandwidth in lowpass, convert to complex bandpass
+    this->get_rx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(dbsrx2_bandwidth_range);
 
-    set_bandwidth(40e6); // default bandwidth from datasheet
-    get_locked();
+    //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
 
-    _max2112_write_regs.bbg = boost::math::iround(dbsrx2_gain_ranges["BBG"].start());
-    send_reg(0x9, 0x9);
+    get_locked();
 }
 
 dbsrx2::~dbsrx2(void){
@@ -213,8 +237,8 @@ dbsrx2::~dbsrx2(void){
 /***********************************************************************
  * Tuning
  **********************************************************************/
-void dbsrx2::set_lo_freq(double target_freq){
-    //target_freq = uhd::clip(target_freq, dbsrx2_freq_range.min, dbsrx2_freq_range.max);
+double dbsrx2::set_lo_freq(double target_freq){
+    //target_freq = dbsrx2_freq_range.clip(target_freq);
 
     //variables used in the calculation below
     int scaler = target_freq > 1125e6 ? 2 : 4;
@@ -257,6 +281,7 @@ void dbsrx2::set_lo_freq(double target_freq){
     //FIXME: probably unnecessary to call get_locked here
     //get_locked();
 
+    return _lo_freq;
 }
 
 /***********************************************************************
@@ -309,7 +334,7 @@ static double gain_to_gc1_rfvga_dac(double &gain){
     return dac_volts;
 }
 
-void dbsrx2::set_gain(double gain, const std::string &name){
+double dbsrx2::set_gain(double gain, const std::string &name){
     assert_has(dbsrx2_gain_ranges.keys(), name, "dbsrx2 gain name");
     if (name == "BBG"){
         _max2112_write_regs.bbg = gain_to_bbg_vga_reg(gain);
@@ -321,14 +346,19 @@ void dbsrx2::set_gain(double gain, const std::string &name){
     }
     else UHD_THROW_INVALID_CODE_PATH();
     _gains[name] = gain;
+
+    return gain;
 }
 
 /***********************************************************************
  * Bandwidth Handling
  **********************************************************************/
-void dbsrx2::set_bandwidth(double bandwidth){
+double dbsrx2::set_bandwidth(double bandwidth){
+    //convert complex bandpass to lowpass bandwidth
+    bandwidth = bandwidth/2.0;
+
     //clip the input
-    bandwidth = uhd::clip<double>(bandwidth, 4e6, 40e6);
+    bandwidth = dbsrx2_bandwidth_range.clip(bandwidth);
 
     _max2112_write_regs.lp = int((bandwidth/1e6 - 4)/0.29 + 12);
     _bandwidth = double(4 + (_max2112_write_regs.lp - 12) * 0.29)*1e6;
@@ -339,105 +369,7 @@ void dbsrx2::set_bandwidth(double bandwidth){
         << std::endl;
 
     this->send_reg(0x8, 0x8);
-}
 
-/***********************************************************************
- * RX Get and Set
- **********************************************************************/
-void dbsrx2::rx_get(const wax::obj &key_, wax::obj &val){
-    named_prop_t key = named_prop_t::extract(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(), key.name, "dbsrx2 gain name");
-        val = _gains[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        assert_has(dbsrx2_gain_ranges.keys(), key.name, "dbsrx2 gain name");
-        val = dbsrx2_gain_ranges[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(dbsrx2_gain_ranges.keys());
-        return;
-
-    case SUBDEV_PROP_FREQ:
-        val = _lo_freq;
-        return;
-
-    case SUBDEV_PROP_FREQ_RANGE:
-        val = dbsrx2_freq_range;
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        val = std::string("J3");
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = dbsrx2_antennas;
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = SUBDEV_CONN_COMPLEX_QI;
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        val = true; //always enabled
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SENSOR:
-        UHD_ASSERT_THROW(key.name == "lo_locked");
-        val = sensor_value_t("LO", this->get_locked(), "locked", "unlocked");
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:
-        val = prop_names_t(1, "lo_locked");
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        val = _bandwidth;
-        return;
-
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
+    //convert lowpass back to complex bandpass bandwidth
+    return 2.0*_bandwidth;
 }
-
-void dbsrx2::rx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(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<double>(), key.name);
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        return; //always enabled
-
-    case SUBDEV_PROP_BANDWIDTH:
-        this->set_bandwidth(val.as<double>());
-        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 3e6d89758..3896534cd 100644
--- a/host/lib/usrp/dboard/db_rfx.cpp
+++ b/host/lib/usrp/dboard/db_rfx.cpp
@@ -211,6 +211,8 @@ rfx_xcvr::rfx_xcvr(
     this->get_rx_subtree()->create<bool>("enabled").set(true); //always enabled
     this->get_rx_subtree()->create<bool>("use_lo_offset").set(false);
     this->get_rx_subtree()->create<double>("bandwidth/value").set(2*20.0e6); //20MHz low-pass, we want complex double-sided
+    this->get_rx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(freq_range_t(2*20.0e6, 2*20.0e6));
 
     ////////////////////////////////////////////////////////////////////
     // Register TX properties
@@ -231,6 +233,8 @@ rfx_xcvr::rfx_xcvr(
     this->get_tx_subtree()->create<bool>("enabled").set(true); //always enabled
     this->get_tx_subtree()->create<bool>("use_lo_offset").set(true);
     this->get_tx_subtree()->create<double>("bandwidth/value").set(2*20.0e6); //20MHz low-pass, we want complex double-sided
+    this->get_tx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(freq_range_t(2*20.0e6, 2*20.0e6));
 
     //enable the clocks that we need
     this->get_iface()->set_clock_enabled(dboard_iface::UNIT_TX, true);
diff --git a/host/lib/usrp/dboard/db_tvrx.cpp b/host/lib/usrp/dboard/db_tvrx.cpp
index 907d798dd..dfa617e77 100644
--- a/host/lib/usrp/dboard/db_tvrx.cpp
+++ b/host/lib/usrp/dboard/db_tvrx.cpp
@@ -57,7 +57,7 @@ using namespace boost::assign;
  **********************************************************************/
 static const freq_range_t tvrx_freq_range(50e6, 860e6);
 
-static const prop_names_t tvrx_antennas = list_of("RX");
+static const std::vector<std::string> tvrx_antennas = list_of("RX");
 
 static const uhd::dict<std::string, freq_range_t> tvrx_freq_ranges = map_list_of
     ("VHFLO", freq_range_t(50e6, 158e6))
@@ -136,9 +136,6 @@ public:
     tvrx(ctor_args_t args);
     ~tvrx(void);
 
-    void rx_get(const wax::obj &key, wax::obj &val);
-    void rx_set(const wax::obj &key, const wax::obj &val);
-
 private:
     uhd::dict<std::string, double> _gains;
     double _lo_freq;
@@ -147,8 +144,8 @@ private:
         return (this->get_iface()->get_special_props().mangle_i2c_addrs)? 0x61 : 0x60; //ok really? we could rename that call
     };
 
-    void set_gain(double gain, const std::string &name);
-    void set_freq(double freq);
+    double set_gain(double gain, const std::string &name);
+    double set_freq(double freq);
 
     void update_regs(void){
         byte_vector_t regs_vector(4);
@@ -185,6 +182,39 @@ UHD_STATIC_BLOCK(reg_tvrx_dboard){
  * Structors
  **********************************************************************/
 tvrx::tvrx(ctor_args_t args) : rx_dboard_base(args){
+    ////////////////////////////////////////////////////////////////////
+    // Register properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_rx_subtree()->create<std::string>("name")
+        .set(get_rx_id().to_pp_string());
+    BOOST_FOREACH(const std::string &name, get_tvrx_gain_ranges().keys()){
+        this->get_rx_subtree()->create<double>("gains/"+name+"/value")
+            .coerce(boost::bind(&tvrx::set_gain, this, _1, name))
+            .set(get_tvrx_gain_ranges()[name].start());
+        this->get_rx_subtree()->create<meta_range_t>("gains/"+name+"/range")
+            .set(get_tvrx_gain_ranges()[name]);
+    }
+    this->get_rx_subtree()->create<double>("freq/value")
+        .coerce(boost::bind(&tvrx::set_freq, this, _1))
+        .set(tvrx_freq_range.start());
+    this->get_rx_subtree()->create<meta_range_t>("freq/range")
+        .set(tvrx_freq_range);
+    this->get_rx_subtree()->create<std::string>("antenna/value")
+        .set(tvrx_antennas.at(0));
+    this->get_rx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(tvrx_antennas);
+    this->get_rx_subtree()->create<std::string>("connection")
+        .set("I");
+    this->get_rx_subtree()->create<bool>("enabled")
+        .set(true); //always enabled
+    this->get_rx_subtree()->create<bool>("use_lo_offset")
+        .set(false);
+    this->get_rx_subtree()->create<double>("bandwidth/value")
+        .set(6.0e6);
+    this->get_rx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(freq_range_t(6.0e6, 6.0e6));
+
+    //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)
@@ -317,7 +347,7 @@ static double if_gain_to_voltage(double gain){
     return dac_volts;
 }
 
-void tvrx::set_gain(double gain, const std::string &name){
+double tvrx::set_gain(double gain, const std::string &name){
     assert_has(get_tvrx_gain_ranges().keys(), name, "tvrx gain name");
     if (name == "RF"){
         this->get_iface()->write_aux_dac(dboard_iface::UNIT_RX, dboard_iface::AUX_DAC_B, rf_gain_to_voltage(gain, _lo_freq));
@@ -327,6 +357,8 @@ void tvrx::set_gain(double gain, const std::string &name){
     }
     else UHD_THROW_INVALID_CODE_PATH();
     _gains[name] = gain;
+
+    return gain;
 }
 
 /*!
@@ -334,7 +366,7 @@ void tvrx::set_gain(double gain, const std::string &name){
  * \param freq the requested frequency
  */
 
-void tvrx::set_freq(double freq) {
+double tvrx::set_freq(double freq) {
     freq = tvrx_freq_range.clip(freq);
     std::string prev_band = get_band(_lo_freq - tvrx_if_freq);
     std::string new_band = get_band(freq);
@@ -367,131 +399,6 @@ void tvrx::set_freq(double freq) {
     UHD_LOGV(often) << boost::format("set_freq: target LO: %f f_ref: %f divisor: %i actual LO: %f") % target_lo_freq % f_ref % divisor % actual_lo_freq << std::endl;
 
     _lo_freq = actual_lo_freq; //for rx props
-}
-
-/***********************************************************************
- * Get the alias frequency of frequency freq when sampled at fs.
- * \param freq the frequency of interest
- * \param fs the sample rate
- * \return the alias frequency
- **********************************************************************/
-
-static double get_alias(double freq, double fs) {
-    double alias;
-    freq = fmod(freq, fs);
-    if(freq >= (fs/2)) {
-        alias = freq - fs;
-    } else {
-        alias = freq;
-    }
-    return alias;
-}
 
-/***********************************************************************
- * RX Get and Set
- **********************************************************************/
-void tvrx::rx_get(const wax::obj &key_, wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-    double codec_rate;
-
-    //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(), key.name, "tvrx gain name");
-        val = _gains[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        assert_has(get_tvrx_gain_ranges().keys(), key.name, "tvrx gain name");
-        val = get_tvrx_gain_ranges()[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(get_tvrx_gain_ranges().keys());
-        return;
-
-    case SUBDEV_PROP_FREQ:
-    /*
-     * so here we have to do some magic. because the TVRX uses a relatively high IF,
-     * we have to watch the sample rate to see if the IF will be aliased
-     * or if it will fall within Nyquist.
-     */
-        codec_rate = this->get_iface()->get_codec_rate(dboard_iface::UNIT_RX);
-        val = (_lo_freq - tvrx_if_freq) + get_alias(tvrx_if_freq, codec_rate);
-        UHD_LOGV(often)
-            << "Getting TVRX freq..." << std::endl
-            << "\tCodec rate: " << codec_rate << std::endl
-            << "\tLO freq: " << _lo_freq << std::endl
-            << "\tIF freq: " << tvrx_if_freq << std::endl
-            << "\tAlias freq: " << get_alias(tvrx_if_freq, codec_rate) << std::endl
-            << "\tCalculated freq: " << val.as<double>() << std::endl;
-        return;
-
-    case SUBDEV_PROP_FREQ_RANGE:
-        val = tvrx_freq_range;
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        val = tvrx_antennas.front(); //there's only one
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = tvrx_antennas;
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = SUBDEV_CONN_REAL_I;
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        val = true; //always enabled
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        val = 6.0e6;
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:
-        val = std::vector<std::string>(); //empty
-        return;
-
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
-}
-
-void tvrx::rx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-    case SUBDEV_PROP_GAIN:
-        this->set_gain(val.as<double>(), key.name);
-        return;
-
-    case SUBDEV_PROP_FREQ:
-        this->set_freq(val.as<double>());
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        return; //always enabled
-
-    case SUBDEV_PROP_BANDWIDTH:
-        UHD_MSG(warning) << "TVRX: No tunable bandwidth, fixed filtered to 6MHz";
-        return;
-
-    default: UHD_THROW_PROP_SET_ERROR();
-    }
+    return _lo_freq;
 }
-
diff --git a/host/lib/usrp/dboard/db_tvrx2.cpp b/host/lib/usrp/dboard/db_tvrx2.cpp
index 23f203b8c..628221527 100644
--- a/host/lib/usrp/dboard/db_tvrx2.cpp
+++ b/host/lib/usrp/dboard/db_tvrx2.cpp
@@ -704,14 +704,22 @@ static const std::vector<tvrx2_tda18272_freq_map_t> tvrx2_tda18272_freq_map = li
 
 static const freq_range_t tvrx2_freq_range(42e6, 870e6);
 
+static const freq_range_t tvrx2_bandwidth_range = list_of
+    (range_t(1.7e6))
+    (range_t(6.0e6))
+    (range_t(7.0e6))
+    (range_t(8.0e6))
+    (range_t(10.0e6))
+;
+
 static const uhd::dict<std::string, std::string> tvrx2_sd_name_to_antennas = map_list_of
     ("RX1", "J100")
     ("RX2", "J140")
 ;
 
-static const uhd::dict<std::string, subdev_conn_t> tvrx2_sd_name_to_conn = map_list_of
-    ("RX1",  SUBDEV_CONN_REAL_Q)
-    ("RX2",  SUBDEV_CONN_REAL_I)
+static const uhd::dict<std::string, std::string> tvrx2_sd_name_to_conn = map_list_of
+    ("RX1",  "Q")
+    ("RX2",  "I")
 ;
 
 static const uhd::dict<std::string, boost::uint8_t> tvrx2_sd_name_to_i2c_addr = map_list_of
@@ -745,9 +753,6 @@ public:
     tvrx2(ctor_args_t args);
     ~tvrx2(void);
 
-    void rx_get(const wax::obj &key, wax::obj &val);
-    void rx_set(const wax::obj &key, const wax::obj &val);
-
 private:
     double _freq_scalar;
     double _lo_freq;
@@ -760,12 +765,11 @@ private:
 
     bool _enabled;
 
-    void set_enabled(void);
-    void set_disabled(void);
+    bool set_enabled(bool);
 
-    void set_lo_freq(double target_freq);
-    void set_gain(double gain, const std::string &name);
-    void set_bandwidth(double bandwidth);
+    double set_lo_freq(double target_freq);
+    double set_gain(double gain, const std::string &name);
+    double set_bandwidth(double bandwidth);
 
     void set_scaled_rf_freq(double rf_freq);
     double get_scaled_rf_freq(void);
@@ -825,10 +829,10 @@ private:
     }
 
     /*!
-     * Is the LO locked?
-     * \return true for locked
+     * Get the lock detect status of the LO.
+     * \return sensor for locked
      */
-    bool get_locked(void){
+    sensor_value_t get_locked(void){
         read_reg(0x5, 0x5);
 
         //return lock detect
@@ -838,14 +842,15 @@ private:
             "TVRX2 (%s): locked %d"
         ) % (get_subdev_name()) % locked << std::endl;
 
-        return locked;
+        return sensor_value_t("LO", locked, "locked", "unlocked");
     }
 
     /*!
      * Read the RSSI from the registers
-     * \return the rssi in dB(m?) FIXME
+     * Read the RSSI from the aux adc
+     * \return the rssi sensor in dB(m?) FIXME
      */
-    double get_rssi(void){
+    sensor_value_t get_rssi(void){
         //Launch RSSI calculation with MSM statemachine
         _tda18272hnm_regs.set_reg(0x19, 0x80); //set MSM_byte_1 for rssi calculation
         _tda18272hnm_regs.set_reg(0x1A, 0x01); //set MSM_byte_2 for launching rssi calculation
@@ -859,14 +864,16 @@ private:
 
         //calculate the rssi from the voltage
         double rssi_dBuV = 40.0 + double(((110.0 - 40.0)/128.0) * _tda18272hnm_regs.get_reg(0x7));
-        return rssi_dBuV - 107.0; //convert to dBm in 50ohm environment ( -108.8 if 75ohm ) FIXME
+        double rssi =  rssi_dBuV - 107.0; //convert to dBm in 50ohm environment ( -108.8 if 75ohm ) FIXME
+
+        return sensor_value_t("RSSI", rssi, "dBm");
     }
 
     /*!
      * Read the Temperature from the registers
      * \return the temp in degC
      */
-    double get_temp(void){
+    sensor_value_t get_temp(void){
         //Enable Temperature reading
         _tda18272hnm_regs.tm_on = tda18272hnm_regs_t::TM_ON_SENSOR_ON;
         send_reg(0x4, 0x4);
@@ -882,7 +889,7 @@ private:
         _tda18272hnm_regs.tm_on = tda18272hnm_regs_t::TM_ON_SENSOR_OFF;
         send_reg(0x4, 0x4);
 
-        return (double(_tda18272hnm_regs.tm_d));
+        return sensor_value_t("TEMP", double(_tda18272hnm_regs.tm_d), "degC");
     }
 };
 
@@ -930,24 +937,64 @@ tvrx2::tvrx2(ctor_args_t args) : rx_dboard_base(args){
         ( 7, tvrx2_tda18272_rfcal_coeffs_t(10) )
     ;
 
-    //set the gpio directions and atr controls (identically)
-    this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_RX, 0); // All unused in atr
-    this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, OUTPUT_MASK); // Set outputs
+    //set defaults for LO, gains, and filter bandwidth
+    _bandwidth = 10e6;
+
+    _if_freq = 12.5e6;
 
-    double ref_clock=0.0;
+    _enabled = false;
 
-    //configure ref_clock
+    //send initial register settings
+    //this->read_reg(0x0, 0x43);
+    //this->send_reg(0x0, 0x43);
 
-    /*
-    std::vector<double> clock_rates = this->get_iface()->get_clock_rates(dboard_iface::UNIT_RX);
-    BOOST_FOREACH(ref_clock, uhd::sorted(clock_rates)){
-        if (ref_clock < 16.0e6) continue; 
-        if (ref_clock >= 16.0e6) break; 
+    //send magic xtal_cal_dac setting
+    send_reg(0x65, 0x65);
+
+    ////////////////////////////////////////////////////////////////////
+    // Register properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_rx_subtree()->create<std::string>("name")
+        .set(get_rx_id().to_pp_string());
+    this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
+        .publish(boost::bind(&tvrx2::get_locked, this));
+    this->get_rx_subtree()->create<sensor_value_t>("sensors/rssi")
+        .publish(boost::bind(&tvrx2::get_rssi, this));
+    this->get_rx_subtree()->create<sensor_value_t>("sensors/temperature")
+        .publish(boost::bind(&tvrx2::get_temp, this));
+    BOOST_FOREACH(const std::string &name, tvrx2_gain_ranges.keys()){
+        this->get_rx_subtree()->create<double>("gains/"+name+"/value")
+            .coerce(boost::bind(&tvrx2::set_gain, this, _1, name));
+        this->get_rx_subtree()->create<meta_range_t>("gains/"+name+"/range")
+            .set(tvrx2_gain_ranges[name]);
     }
-    this->get_iface()->set_clock_rate(dboard_iface::UNIT_RX, ref_clock);
-    */
+    this->get_rx_subtree()->create<double>("freq/value")
+        .coerce(boost::bind(&tvrx2::set_lo_freq, this, _1));
+    this->get_rx_subtree()->create<meta_range_t>("freq/range")
+        .set(tvrx2_freq_range);
+    this->get_rx_subtree()->create<std::string>("antenna/value")
+        .set(tvrx2_sd_name_to_antennas[get_subdev_name()]);
+    this->get_rx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(list_of(tvrx2_sd_name_to_antennas[get_subdev_name()]));
+    this->get_rx_subtree()->create<std::string>("connection")
+        .set(tvrx2_sd_name_to_conn[get_subdev_name()]);
+    this->get_rx_subtree()->create<bool>("enabled")
+        .coerce(boost::bind(&tvrx2::set_enabled, this, _1))
+        .set(_enabled);
+    this->get_rx_subtree()->create<bool>("use_lo_offset")
+        .set(false);
+    this->get_rx_subtree()->create<double>("bandwidth/value")
+        .coerce(boost::bind(&tvrx2::set_bandwidth, this, _1))
+        .set(_bandwidth);
+    this->get_rx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(tvrx2_bandwidth_range);
 
-    ref_clock = this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX);
+    //set the gpio directions and atr controls (identically)
+    this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_RX, 0); // All unused in atr
+    this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, OUTPUT_MASK); // Set outputs
+
+    //configure ref_clock
+    double ref_clock = this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX);
 
     if (ref_clock == 64.0e6) {
         this->get_iface()->set_gpio_out(dboard_iface::UNIT_RX, REFCLOCK_DIV4);
@@ -978,22 +1025,6 @@ tvrx2::tvrx2(ctor_args_t args) : rx_dboard_base(args){
         "TVRX2 (%s): Refclock %f Hz, scalar = %f"
     ) % (get_subdev_name()) % (this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX)) % _freq_scalar << std::endl;
 
-    //set defaults for LO, gains, and filter bandwidth
-    _bandwidth = 10e6;
-
-    _if_freq = 12.5e6;
-
-    _lo_freq = tvrx2_freq_range.start();
-
-    _enabled = false;
-
-    //send initial register settings
-    //this->read_reg(0x0, 0x43);
-    //this->send_reg(0x0, 0x43);
-
-    //send magic xtal_cal_dac setting
-    send_reg(0x65, 0x65);
-
     _tda18272hnm_regs.irq_polarity = tda18272hnm_regs_t::IRQ_POLARITY_RAISED_VCC;
     _tda18272hnm_regs.irq_clear = tda18272hnm_regs_t::IRQ_CLEAR_TRUE;
     send_reg(0x37, 0x37);
@@ -1013,39 +1044,47 @@ tvrx2::tvrx2(ctor_args_t args) : rx_dboard_base(args){
     transition_0();
 }
 
-void tvrx2::set_enabled(void){
-    //setup tuner parameters
-    transition_1();
+bool tvrx2::set_enabled(bool enable){
+    if (enable == _enabled) return _enabled;
 
-    transition_2(int(tvrx2_freq_range.start()));
+    if (enable and not _enabled){
+        //setup tuner parameters
+        transition_1();
 
-    test_rf_filter_robustness();
+        transition_2(int(tvrx2_freq_range.start()));
 
-    BOOST_FOREACH(const std::string &name, tvrx2_gain_ranges.keys()){
-        set_gain(tvrx2_gain_ranges[name].start(), name);
-    }
+        test_rf_filter_robustness();
+
+        BOOST_FOREACH(const std::string &name, tvrx2_gain_ranges.keys()){
+            this->get_rx_subtree()->access<double>("gains/"+name+"/value")
+                .set(tvrx2_gain_ranges[name].start());
+        }
+
+        this->get_rx_subtree()->access<double>("bandwidth/value")
+            .set(_bandwidth); // default bandwidth from datasheet
+
+        //transition_2 equivalent
+        this->get_rx_subtree()->access<double>("freq/value")
+            .set(tvrx2_freq_range.start());
 
-    set_bandwidth(_bandwidth); // default bandwidth from datasheet
+        //enter standby mode
+        transition_3();
+        _enabled = true;
 
-    //transition_2 equivalent
-    set_lo_freq(tvrx2_freq_range.start());
+    } else {
+        //enter standby mode
+        transition_3();
+        _enabled = false;
+    }
 
-    //enter standby mode
-    transition_3();
-    _enabled = true;
+    return _enabled;
 }
 
 tvrx2::~tvrx2(void){
     UHD_LOGV(often) << boost::format(
         "TVRX2 (%s): Called Destructor"
     ) % (get_subdev_name()) << std::endl;
-    UHD_SAFE_CALL(if (_enabled) set_disabled();)
-}
-
-void tvrx2::set_disabled(void){
-    //enter standby mode
-    transition_3();
-    _enabled = false;
+    UHD_SAFE_CALL(if (_enabled) set_enabled(false);)
 }
 
 
@@ -1682,7 +1721,7 @@ void tvrx2::wait_irq(void){
 /***********************************************************************
  * Tuning
  **********************************************************************/
-void tvrx2::set_lo_freq(double target_freq){
+double tvrx2::set_lo_freq(double target_freq){
     //target_freq = std::clip(target_freq, tvrx2_freq_range.min, tvrx2_freq_range.max);
 
     read_reg(0x6, 0x6);
@@ -1711,7 +1750,9 @@ void tvrx2::set_lo_freq(double target_freq){
 
     UHD_LOGV(often) << boost::format(
         "\nTVRX2 (%s): RSSI = %f dBm\n"
-    ) % (get_subdev_name()) % (get_rssi()) << std::endl;
+    ) % (get_subdev_name()) % (get_rssi().to_real()) << std::endl;
+
+    return _lo_freq;
 }
 
 /***********************************************************************
@@ -1741,7 +1782,7 @@ static double gain_to_if_gain_dac(double &gain){
     return dac_volts;
 }
 
-void tvrx2::set_gain(double gain, const std::string &name){
+double tvrx2::set_gain(double gain, const std::string &name){
     assert_has(tvrx2_gain_ranges.keys(), name, "tvrx2 gain name");
 
     if (name == "IF"){
@@ -1752,6 +1793,8 @@ void tvrx2::set_gain(double gain, const std::string &name){
 
     //shadow gain setting
     _gains[name] = gain;
+
+    return gain;
 }
 
 /***********************************************************************
@@ -1780,7 +1823,10 @@ static tda18272hnm_regs_t::lp_fc_t bandwidth_to_lp_fc_reg(double &bandwidth){
     UHD_THROW_INVALID_CODE_PATH();
 }
 
-void tvrx2::set_bandwidth(double bandwidth){
+double tvrx2::set_bandwidth(double bandwidth){
+    //clip the input
+    bandwidth = tvrx2_bandwidth_range.clip(bandwidth);
+
     //compute low pass cutoff frequency setting
     _tda18272hnm_regs.lp_fc = bandwidth_to_lp_fc_reg(bandwidth);
 
@@ -1793,119 +1839,6 @@ void tvrx2::set_bandwidth(double bandwidth){
     UHD_LOGV(often) << boost::format(
         "TVRX2 (%s) Bandwidth (lp_fc): %f Hz, reg: %d"
     ) % (get_subdev_name()) % _bandwidth % (int(_tda18272hnm_regs.lp_fc)) << std::endl;
-}
-
-/***********************************************************************
- * RX Get and Set
- **********************************************************************/
-void tvrx2::rx_get(const wax::obj &key_, wax::obj &val){
-    named_prop_t key = named_prop_t::extract(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(), key.name, "tvrx2 gain name");
-        val = _gains[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        assert_has(tvrx2_gain_ranges.keys(), key.name, "tvrx2 gain name");
-        val = tvrx2_gain_ranges[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(tvrx2_gain_ranges.keys());
-        return;
-
-    case SUBDEV_PROP_FREQ:
-        val = _lo_freq;
-        return;
-
-    case SUBDEV_PROP_FREQ_RANGE:
-        val = tvrx2_freq_range;
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        val = tvrx2_sd_name_to_antennas[get_subdev_name()];
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = prop_names_t(1, tvrx2_sd_name_to_antennas[get_subdev_name()]);
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = tvrx2_sd_name_to_conn[get_subdev_name()];
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        val = _enabled;
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SENSOR:
-        if (key.name == "lo_locked")
-            val = sensor_value_t("LO", this->get_locked(), "locked", "unlocked");
-        else if (key.name == "rssi")
-            val = sensor_value_t("RSSI", this->get_rssi(), "dBm");
-        else if (key.name == "temperature")
-            val = sensor_value_t("TEMP", this->get_temp(), "degC");
-        else
-            UHD_THROW_INVALID_CODE_PATH();
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:{
-            prop_names_t names = list_of("lo_locked")("rssi")("temperature");
-            val = names;
-        }
-        return;
 
-    case SUBDEV_PROP_BANDWIDTH:
-        val = _bandwidth;
-        return;
-
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
+    return _bandwidth;
 }
-
-void tvrx2::rx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(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<double>(), key.name);
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        if ((val.as<bool>())) this->set_enabled();
-        else if (not (val.as<bool>())) this->set_disabled();
-
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        this->set_bandwidth(val.as<double>());
-        return;
-
-    default: UHD_THROW_PROP_SET_ERROR();
-    }
-}
-
diff --git a/host/lib/usrp/dboard/db_unknown.cpp b/host/lib/usrp/dboard/db_unknown.cpp
index 3a11f1e5b..2ed50cd91 100644
--- a/host/lib/usrp/dboard/db_unknown.cpp
+++ b/host/lib/usrp/dboard/db_unknown.cpp
@@ -64,17 +64,11 @@ static void warn_if_old_rfx(const dboard_id_t &dboard_id, const std::string &xx)
 class unknown_rx : public rx_dboard_base{
 public:
     unknown_rx(ctor_args_t args);
-
-    void rx_get(const wax::obj &key, wax::obj &val);
-    void rx_set(const wax::obj &key, const wax::obj &val);
 };
 
 class unknown_tx : public tx_dboard_base{
 public:
     unknown_tx(ctor_args_t args);
-
-    void tx_get(const wax::obj &key, wax::obj &val);
-    void tx_set(const wax::obj &key, const wax::obj &val);
 };
 
 /***********************************************************************
@@ -98,99 +92,35 @@ UHD_STATIC_BLOCK(reg_unknown_dboards){
  **********************************************************************/
 unknown_rx::unknown_rx(ctor_args_t args) : rx_dboard_base(args){
     warn_if_old_rfx(this->get_rx_id(), "RX");
-}
-
-void unknown_rx::rx_get(const wax::obj &key_, wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-    case SUBDEV_PROP_NAME:
-        val = "Unknown - " + get_rx_id().to_pp_string();
-        return;
-
-    case SUBDEV_PROP_OTHERS:
-        val = prop_names_t(); //empty
-        return;
-
-    case SUBDEV_PROP_GAIN:
-        val = double(0);
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        val = gain_range_t(0, 0, 0);
-        return;
-
-    case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(); //empty
-        return;
-
-    case SUBDEV_PROP_FREQ:
-        val = double(0);
-        return;
-
-    case SUBDEV_PROP_FREQ_RANGE:
-        val = freq_range_t(0.0, 0.0);
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        val = std::string("");
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = prop_names_t(1, ""); //vector of 1 empty string
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:
-        val = std::vector<std::string>(); //empty
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = SUBDEV_CONN_COMPLEX_IQ;
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        val = true; //always enabled
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        val = 0.0;
-        return;
-
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
-}
-
-void unknown_rx::rx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-
-    case SUBDEV_PROP_GAIN:
-        UHD_ASSERT_THROW(val.as<double>() == double(0));
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        if (val.as<std::string>().empty()) return;
-        throw uhd::value_error("Unknown Daughterboard: No selectable antenna");
-
-    case SUBDEV_PROP_FREQ:
-        return; // it wont do you much good, but you can set it
-
-    case SUBDEV_PROP_ENABLED:
-        return; //always enabled
-
-    case SUBDEV_PROP_BANDWIDTH:
-        UHD_MSG(warning) << "Unknown Daughterboard: No tunable bandwidth, fixed filtered to 0.0MHz";
-        return;
 
-    default: UHD_THROW_PROP_SET_ERROR();
-    }
+    ////////////////////////////////////////////////////////////////////
+    // Register properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_rx_subtree()->create<std::string>("name").set(
+        std::string(str(boost::format("%s - %s")
+            % get_rx_id().to_pp_string()
+            % get_subdev_name()
+        )));
+    this->get_rx_subtree()->create<int>("gains"); //phony property so this dir exists
+    this->get_rx_subtree()->create<double>("freq/value")
+        .set(double(0.0));
+    this->get_rx_subtree()->create<meta_range_t>("freq/range")
+        .set(freq_range_t(double(0.0), double(0.0)));
+    this->get_rx_subtree()->create<std::string>("antenna/value")
+        .set("");
+    this->get_rx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(list_of(""));
+    this->get_rx_subtree()->create<int>("sensors"); //phony property so this dir exists
+    this->get_rx_subtree()->create<std::string>("connection")
+        .set("IQ");
+    this->get_rx_subtree()->create<bool>("enabled")
+        .set(true); //always enabled
+    this->get_rx_subtree()->create<bool>("use_lo_offset")
+        .set(false);
+    this->get_rx_subtree()->create<double>("bandwidth/value")
+        .set(double(0.0));
+    this->get_rx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(freq_range_t(0.0, 0.0));
 }
 
 /***********************************************************************
@@ -198,97 +128,33 @@ void unknown_rx::rx_set(const wax::obj &key_, const wax::obj &val){
  **********************************************************************/
 unknown_tx::unknown_tx(ctor_args_t args) : tx_dboard_base(args){
     warn_if_old_rfx(this->get_tx_id(), "TX");
-}
-
-void unknown_tx::tx_get(const wax::obj &key_, wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-    case SUBDEV_PROP_NAME:
-        val = "Unknown - " + get_tx_id().to_pp_string();
-        return;
-
-    case SUBDEV_PROP_OTHERS:
-        val = prop_names_t(); //empty
-        return;
-
-    case SUBDEV_PROP_GAIN:
-        val = double(0);
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        val = gain_range_t(0, 0, 0);
-        return;
-
-    case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(); //empty
-        return;
-
-    case SUBDEV_PROP_FREQ:
-        val = double(0);
-        return;
-
-    case SUBDEV_PROP_FREQ_RANGE:
-        val = freq_range_t(0.0, 0.0);
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        val = std::string("");
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = prop_names_t(1, ""); //vector of 1 empty string
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:
-        val = std::vector<std::string>(); //empty
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = SUBDEV_CONN_COMPLEX_IQ;
-        return;
 
-    case SUBDEV_PROP_ENABLED:
-        val = true; //always enabled
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        val = 0.0;
-        return;
-
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
-}
-
-void unknown_tx::tx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-
-    case SUBDEV_PROP_GAIN:
-        UHD_ASSERT_THROW(val.as<double>() == double(0));
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        if (val.as<std::string>().empty()) return;
-        throw uhd::value_error("Unknown Daughterboard: No selectable antenna");
-
-    case SUBDEV_PROP_FREQ:
-        return; // it wont do you much good, but you can set it
-
-    case SUBDEV_PROP_ENABLED:
-        return; //always enabled
-
-    case SUBDEV_PROP_BANDWIDTH:
-        UHD_MSG(warning) << "Unknown Daughterboard: No tunable bandwidth, fixed filtered to 0.0MHz";
-        return;
-
-    default: UHD_THROW_PROP_SET_ERROR();
-    }
+    ////////////////////////////////////////////////////////////////////
+    // Register properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_tx_subtree()->create<std::string>("name").set(
+        std::string(str(boost::format("%s - %s")
+            % get_tx_id().to_pp_string()
+            % get_subdev_name()
+        )));
+    this->get_tx_subtree()->create<int>("gains"); //phony property so this dir exists
+    this->get_tx_subtree()->create<double>("freq/value")
+        .set(double(0.0));
+    this->get_tx_subtree()->create<meta_range_t>("freq/range")
+        .set(freq_range_t(double(0.0), double(0.0)));
+    this->get_tx_subtree()->create<std::string>("antenna/value")
+        .set("");
+    this->get_tx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(list_of(""));
+    this->get_tx_subtree()->create<int>("sensors"); //phony property so this dir exists
+    this->get_tx_subtree()->create<std::string>("connection")
+        .set("IQ");
+    this->get_tx_subtree()->create<bool>("enabled")
+        .set(true); //always enabled
+    this->get_tx_subtree()->create<bool>("use_lo_offset")
+        .set(false);
+    this->get_tx_subtree()->create<double>("bandwidth/value")
+        .set(double(0.0));
+    this->get_tx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(freq_range_t(0.0, 0.0));
 }
diff --git a/host/lib/usrp/dboard/db_xcvr2450.cpp b/host/lib/usrp/dboard/db_xcvr2450.cpp
index bfd4421b8..bdc6aa9fe 100644
--- a/host/lib/usrp/dboard/db_xcvr2450.cpp
+++ b/host/lib/usrp/dboard/db_xcvr2450.cpp
@@ -76,7 +76,22 @@ static const freq_range_t xcvr_freq_range = list_of
     (range_t(4.9e9, 6.0e9))
 ;
 
-static const prop_names_t xcvr_antennas = list_of("J1")("J2");
+//Multiplied by 2.0 for conversion to complex bandpass from lowpass
+static const freq_range_t xcvr_tx_bandwidth_range = list_of
+    (range_t(2.0*12e6))
+    (range_t(2.0*18e6))
+    (range_t(2.0*24e6))
+;
+
+//Multiplied by 2.0 for conversion to complex bandpass from lowpass
+static const freq_range_t xcvr_rx_bandwidth_range = list_of
+    (range_t(2.0*0.9*7.5e6, 2.0*1.1*7.5e6))
+    (range_t(2.0*0.9*9.5e6, 2.0*1.1*9.5e6))
+    (range_t(2.0*0.9*14e6,  2.0*1.1*14e6))
+    (range_t(2.0*0.9*18e6,  2.0*1.1*18e6))
+;
+
+static const std::vector<std::string> xcvr_antennas = list_of("J1")("J2");
 
 static const uhd::dict<std::string, gain_range_t> xcvr_tx_gain_ranges = map_list_of
     ("VGA", gain_range_t(0, 30, 0.5))
@@ -99,12 +114,6 @@ public:
     xcvr2450(ctor_args_t args);
     ~xcvr2450(void);
 
-    void rx_get(const wax::obj &key, wax::obj &val);
-    void rx_set(const wax::obj &key, const wax::obj &val);
-
-    void tx_get(const wax::obj &key, wax::obj &val);
-    void tx_set(const wax::obj &key, const wax::obj &val);
-
 private:
     double _lo_freq;
     double _rx_bandwidth, _tx_bandwidth;
@@ -113,14 +122,14 @@ private:
     int _ad9515div;
     max2829_regs_t _max2829_regs;
 
-    void set_lo_freq(double target_freq);
-    void set_lo_freq_core(double target_freq);
+    double set_lo_freq(double target_freq);
+    double set_lo_freq_core(double target_freq);
     void set_tx_ant(const std::string &ant);
     void set_rx_ant(const std::string &ant);
-    void set_tx_gain(double gain, const std::string &name);
-    void set_rx_gain(double gain, const std::string &name);
-    void set_rx_bandwidth(double bandwidth);
-    void set_tx_bandwidth(double bandwidth);
+    double set_tx_gain(double gain, const std::string &name);
+    double set_rx_gain(double gain, const std::string &name);
+    double set_rx_bandwidth(double bandwidth);
+    double set_tx_bandwidth(double bandwidth);
 
     void update_atr(void);
     void spi_reset(void);
@@ -139,18 +148,19 @@ private:
     static bool is_highband(double freq){return freq > 3e9;}
 
     /*!
-     * Is the LO locked?
-     * \return true for locked
+     * Get the lock detect status of the LO.
+     * \return sensor for locked
      */
-    bool get_locked(void){
-        return (this->get_iface()->read_gpio(dboard_iface::UNIT_RX) & LOCKDET_RXIO) != 0;
+    sensor_value_t get_locked(void){
+        const bool locked = (this->get_iface()->read_gpio(dboard_iface::UNIT_RX) & LOCKDET_RXIO) != 0;
+        return sensor_value_t("LO", locked, "locked", "unlocked");
     }
 
     /*!
      * Read the RSSI from the aux adc
-     * \return the rssi in dB
+     * \return the rssi sensor in dBm
      */
-    double get_rssi(void){
+    sensor_value_t get_rssi(void){
         //*FIXME* RSSI depends on LNA Gain Setting (datasheet pg 16 top middle chart)
         double max_power = 0.0;
         switch(_max2829_regs.rx_lna_gain){
@@ -165,7 +175,8 @@ private:
         static const double rssi_dyn_range = 60;
         //calculate the rssi from the voltage
         double voltage = this->get_iface()->read_aux_adc(dboard_iface::UNIT_RX, dboard_iface::AUX_ADC_B);
-        return max_power - rssi_dyn_range*(voltage - min_v)/(max_v - min_v);
+        double rssi = max_power - rssi_dyn_range*(voltage - min_v)/(max_v - min_v);
+        return sensor_value_t("RSSI", rssi, "dBm");
     }
 };
 
@@ -185,15 +196,6 @@ UHD_STATIC_BLOCK(reg_xcvr2450_dboard){
  * Structors
  **********************************************************************/
 xcvr2450::xcvr2450(ctor_args_t args) : xcvr_dboard_base(args){
-    //enable only the clocks we need
-    this->get_iface()->set_clock_enabled(dboard_iface::UNIT_TX, true);
-
-    //set the gpio directions and atr controls (identically)
-    this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_TX, TXIO_MASK);
-    this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_RX, RXIO_MASK);
-    this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_TX, TXIO_MASK);
-    this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, RXIO_MASK);
-
     spi_reset(); //prepare the spi
 
     _rx_bandwidth = 9.5e6;
@@ -222,16 +224,88 @@ xcvr2450::xcvr2450(ctor_args_t args) : xcvr_dboard_base(args){
         this->send_reg(reg);
     }
 
-    //set defaults for LO, gains, antennas
-    set_lo_freq(2.45e9);
-    set_rx_ant(xcvr_antennas.at(0));
-    set_tx_ant(xcvr_antennas.at(1));
-    BOOST_FOREACH(const std::string &name, xcvr_tx_gain_ranges.keys()){
-        set_tx_gain(xcvr_tx_gain_ranges[name].start(), name);
+    ////////////////////////////////////////////////////////////////////
+    // Register RX properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_rx_subtree()->create<std::string>("name")
+        .set(get_rx_id().to_pp_string());
+    this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
+        .publish(boost::bind(&xcvr2450::get_locked, this));
+    this->get_rx_subtree()->create<sensor_value_t>("sensors/rssi")
+        .publish(boost::bind(&xcvr2450::get_rssi, this));
+    BOOST_FOREACH(const std::string &name, xcvr_rx_gain_ranges.keys()){
+        this->get_rx_subtree()->create<double>("gains/"+name+"/value")
+            .coerce(boost::bind(&xcvr2450::set_rx_gain, this, _1, name))
+            .set(xcvr_rx_gain_ranges[name].start());
+        this->get_rx_subtree()->create<meta_range_t>("gains/"+name+"/range")
+            .set(xcvr_rx_gain_ranges[name]);
     }
+    this->get_rx_subtree()->create<double>("freq/value")
+        .coerce(boost::bind(&xcvr2450::set_lo_freq, this, _1))
+        .set(double(2.45e9));
+    this->get_rx_subtree()->create<meta_range_t>("freq/range")
+        .set(xcvr_freq_range);
+    this->get_rx_subtree()->create<std::string>("antenna/value")
+        .subscribe(boost::bind(&xcvr2450::set_rx_ant, this, _1))
+        .set(xcvr_antennas.at(0));
+    this->get_rx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(xcvr_antennas);
+    this->get_rx_subtree()->create<std::string>("connection")
+        .set("IQ");
+    this->get_rx_subtree()->create<bool>("enabled")
+        .set(true); //always enabled
+    this->get_rx_subtree()->create<bool>("use_lo_offset")
+        .set(false);
+    this->get_rx_subtree()->create<double>("bandwidth/value")
+        .coerce(boost::bind(&xcvr2450::set_rx_bandwidth, this, _1)) //complex bandpass bandwidth 
+        .set(2.0*_rx_bandwidth); //_rx_bandwidth in lowpass, convert to complex bandpass
+    this->get_rx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(xcvr_rx_bandwidth_range);
+
+    ////////////////////////////////////////////////////////////////////
+    // Register TX properties
+    ////////////////////////////////////////////////////////////////////
+    this->get_tx_subtree()->create<std::string>("name")
+        .set(get_tx_id().to_pp_string());
+    this->get_tx_subtree()->create<sensor_value_t>("sensors/lo_locked")
+        .publish(boost::bind(&xcvr2450::get_locked, this));
     BOOST_FOREACH(const std::string &name, xcvr_rx_gain_ranges.keys()){
-        set_rx_gain(xcvr_rx_gain_ranges[name].start(), name);
+        this->get_rx_subtree()->create<double>("gains/"+name+"/value")
+            .coerce(boost::bind(&xcvr2450::set_rx_gain, this, _1, name))
+            .set(xcvr_rx_gain_ranges[name].start());
+        this->get_rx_subtree()->create<meta_range_t>("gains/"+name+"/range")
+            .set(xcvr_rx_gain_ranges[name]);
     }
+    this->get_tx_subtree()->create<double>("freq/value")
+        .coerce(boost::bind(&xcvr2450::set_lo_freq, this, _1))
+        .set(double(2.45e9));
+    this->get_tx_subtree()->create<meta_range_t>("freq/range")
+        .set(xcvr_freq_range);
+    this->get_tx_subtree()->create<std::string>("antenna/value")
+        .subscribe(boost::bind(&xcvr2450::set_tx_ant, this, _1))
+        .set(xcvr_antennas.at(1));
+    this->get_tx_subtree()->create<std::vector<std::string> >("antenna/options")
+        .set(xcvr_antennas);
+    this->get_tx_subtree()->create<std::string>("connection")
+        .set("IQ");
+    this->get_tx_subtree()->create<bool>("enabled")
+        .set(true); //always enabled
+    this->get_tx_subtree()->create<bool>("use_lo_offset")
+        .set(true);
+    this->get_tx_subtree()->create<double>("bandwidth/value")
+        .coerce(boost::bind(&xcvr2450::set_tx_bandwidth, this, _1)) //complex bandpass bandwidth
+        .set(2.0*_tx_bandwidth); //_tx_bandwidth in lowpass, convert to complex bandpass
+    this->get_tx_subtree()->create<meta_range_t>("bandwidth/range")
+        .set(xcvr_tx_bandwidth_range);
+
+    //enable only the clocks we need
+    this->get_iface()->set_clock_enabled(dboard_iface::UNIT_TX, true);
+
+    //set the gpio directions and atr controls (identically)
+    this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_TX, TXIO_MASK);
+    this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_RX, RXIO_MASK);
+    this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_TX, TXIO_MASK);
+    this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, RXIO_MASK);
 }
 
 xcvr2450::~xcvr2450(void){
@@ -249,6 +323,9 @@ void xcvr2450::spi_reset(void){
     boost::this_thread::sleep(boost::posix_time::milliseconds(10));
 }
 
+/***********************************************************************
+ * Update ATR regs which change with Antenna or Freq
+ **********************************************************************/
 void xcvr2450::update_atr(void){
     //calculate tx atr pins
     int band_sel   = (xcvr2450::is_highband(_lo_freq))? HB_PA_TXIO : LB_PA_TXIO;
@@ -274,17 +351,19 @@ void xcvr2450::update_atr(void){
 /***********************************************************************
  * Tuning
  **********************************************************************/
-void xcvr2450::set_lo_freq(double target_freq){
+double xcvr2450::set_lo_freq(double target_freq){
     //tune the LO and sleep a bit for lock
     //if not locked, try some carrier offsets
+    double actual = 0.0;
     for (double offset = 0.0; offset <= 3e6; offset+=1e6){
-        this->set_lo_freq_core(target_freq + offset);
+        actual = this->set_lo_freq_core(target_freq + offset);
         boost::this_thread::sleep(boost::posix_time::milliseconds(50));
-        if (this->get_locked()) return;
+        if (this->get_locked().to_bool()) break;
     }
+    return actual;
 }
 
-void xcvr2450::set_lo_freq_core(double target_freq){
+double xcvr2450::set_lo_freq_core(double target_freq){
 
     //clip the input to the range
     target_freq = xcvr_freq_range.clip(target_freq);
@@ -348,6 +427,8 @@ void xcvr2450::set_lo_freq_core(double target_freq){
     this->send_reg(0x5);
     _max2829_regs.vco_bandswitch = max2829_regs_t::VCO_BANDSWITCH_AUTOMATIC;;
     this->send_reg(0x5);
+
+    return _lo_freq;
 }
 
 /***********************************************************************
@@ -441,7 +522,7 @@ static int gain_to_rx_lna_reg(double &gain){
     return reg;
 }
 
-void xcvr2450::set_tx_gain(double gain, const std::string &name){
+double xcvr2450::set_tx_gain(double gain, const std::string &name){
     assert_has(xcvr_tx_gain_ranges.keys(), name, "xcvr tx gain name");
     if (name == "VGA"){
         _max2829_regs.tx_vga_gain = gain_to_tx_vga_reg(gain);
@@ -453,9 +534,11 @@ void xcvr2450::set_tx_gain(double gain, const std::string &name){
     }
     else UHD_THROW_INVALID_CODE_PATH();
     _tx_gains[name] = gain;
+
+    return gain;
 }
 
-void xcvr2450::set_rx_gain(double gain, const std::string &name){
+double xcvr2450::set_rx_gain(double gain, const std::string &name){
     assert_has(xcvr_rx_gain_ranges.keys(), name, "xcvr rx gain name");
     if (name == "VGA"){
         _max2829_regs.rx_vga_gain = gain_to_rx_vga_reg(gain);
@@ -467,6 +550,8 @@ void xcvr2450::set_rx_gain(double gain, const std::string &name){
     }
     else UHD_THROW_INVALID_CODE_PATH();
     _rx_gains[name] = gain;
+
+    return gain;
 }
 
 
@@ -541,9 +626,12 @@ static max2829_regs_t::rx_lpf_coarse_adj_t bandwidth_to_rx_lpf_coarse_reg(double
     UHD_THROW_INVALID_CODE_PATH();
 }
 
-void xcvr2450::set_rx_bandwidth(double bandwidth){
+double xcvr2450::set_rx_bandwidth(double bandwidth){
     double requested_bandwidth = bandwidth;
 
+    //convert complex bandpass to lowpass bandwidth
+    bandwidth = bandwidth/2.0;
+
     //compute coarse low pass cutoff frequency setting
     _max2829_regs.rx_lpf_coarse_adj = bandwidth_to_rx_lpf_coarse_reg(bandwidth);
 
@@ -559,9 +647,14 @@ void xcvr2450::set_rx_bandwidth(double bandwidth){
     UHD_LOGV(often) << boost::format(
         "XCVR2450 RX Bandwidth (lp_fc): %f Hz, coarse reg: %d, fine reg: %d"
     ) % _rx_bandwidth % (int(_max2829_regs.rx_lpf_coarse_adj)) % (int(_max2829_regs.rx_lpf_fine_adj)) << std::endl;
+
+    return 2.0*_rx_bandwidth;
 }
 
-void xcvr2450::set_tx_bandwidth(double bandwidth){
+double xcvr2450::set_tx_bandwidth(double bandwidth){
+    //convert complex bandpass to lowpass bandwidth
+    bandwidth = bandwidth/2.0;
+
     //compute coarse low pass cutoff frequency setting
     _max2829_regs.tx_lpf_coarse_adj = bandwidth_to_tx_lpf_coarse_reg(bandwidth);
 
@@ -574,219 +667,7 @@ void xcvr2450::set_tx_bandwidth(double bandwidth){
     UHD_LOGV(often) << boost::format(
         "XCVR2450 TX Bandwidth (lp_fc): %f Hz, coarse reg: %d"
     ) % _tx_bandwidth % (int(_max2829_regs.tx_lpf_coarse_adj)) << std::endl;
-}
-
-
-/***********************************************************************
- * RX Get and Set
- **********************************************************************/
-void xcvr2450::rx_get(const wax::obj &key_, wax::obj &val){
-    named_prop_t key = named_prop_t::extract(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(_rx_gains.keys(), key.name, "xcvr rx gain name");
-        val = _rx_gains[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        assert_has(xcvr_rx_gain_ranges.keys(), key.name, "xcvr rx gain name");
-        val = xcvr_rx_gain_ranges[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(xcvr_rx_gain_ranges.keys());
-        return;
-
-    case SUBDEV_PROP_FREQ:
-        val = _lo_freq;
-        return;
-
-    case SUBDEV_PROP_FREQ_RANGE:
-        val = xcvr_freq_range;
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        val = _rx_ant;
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = xcvr_antennas;
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = SUBDEV_CONN_COMPLEX_IQ;
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        val = true; //always enabled
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SENSOR:
-        if (key.name == "lo_locked")
-            val = sensor_value_t("LO", this->get_locked(), "locked", "unlocked");
-        else if (key.name == "rssi")
-            val = sensor_value_t("RSSI", this->get_rssi(), "dBm");
-        else
-            UHD_THROW_INVALID_CODE_PATH();
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:{
-            prop_names_t names = list_of("lo_locked")("rssi");
-            val = names;
-        }
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        val = 2*_rx_bandwidth; //_tx_bandwidth is low-pass, we want complex double-sided
-        return;
-
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
-}
-
-void xcvr2450::rx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(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_rx_gain(val.as<double>(), key.name);
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        this->set_rx_ant(val.as<std::string>());
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        this->set_rx_bandwidth(val.as<double>()/2.0); //complex double-sided, we want low-pass
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        return; //always enabled
 
-    default: UHD_THROW_PROP_SET_ERROR();
-    }
-}
-
-/***********************************************************************
- * TX Get and Set
- **********************************************************************/
-void xcvr2450::tx_get(const wax::obj &key_, wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-    case SUBDEV_PROP_NAME:
-        val = get_tx_id().to_pp_string();
-        return;
-
-    case SUBDEV_PROP_OTHERS:
-        val = prop_names_t(); //empty
-        return;
-
-    case SUBDEV_PROP_GAIN:
-        assert_has(_tx_gains.keys(), key.name, "xcvr tx gain name");
-        val = _tx_gains[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_RANGE:
-        assert_has(xcvr_tx_gain_ranges.keys(), key.name, "xcvr tx gain name");
-        val = xcvr_tx_gain_ranges[key.name];
-        return;
-
-    case SUBDEV_PROP_GAIN_NAMES:
-        val = prop_names_t(xcvr_tx_gain_ranges.keys());
-        return;
-
-    case SUBDEV_PROP_FREQ:
-        val = _lo_freq;
-        return;
-
-    case SUBDEV_PROP_FREQ_RANGE:
-        val = xcvr_freq_range;
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        val = _tx_ant;
-        return;
-
-    case SUBDEV_PROP_ANTENNA_NAMES:
-        val = xcvr_antennas;
-        return;
-
-    case SUBDEV_PROP_CONNECTION:
-        val = SUBDEV_CONN_COMPLEX_QI;
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        val = true; //always enabled
-        return;
-
-    case SUBDEV_PROP_USE_LO_OFFSET:
-        val = false;
-        return;
-
-    case SUBDEV_PROP_SENSOR:
-        UHD_ASSERT_THROW(key.name == "lo_locked");
-        val = sensor_value_t("LO", this->get_locked(), "locked", "unlocked");
-        return;
-
-    case SUBDEV_PROP_SENSOR_NAMES:
-        val = prop_names_t(1, "lo_locked");
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        val = 2*_tx_bandwidth; //_tx_bandwidth is low-pass, we want complex double-sided
-        return;
-
-    default: UHD_THROW_PROP_GET_ERROR();
-    }
-}
-
-void xcvr2450::tx_set(const wax::obj &key_, const wax::obj &val){
-    named_prop_t key = named_prop_t::extract(key_);
-
-    //handle the get request conditioned on the key
-    switch(key.as<subdev_prop_t>()){
-
-    case SUBDEV_PROP_FREQ:
-        set_lo_freq(val.as<double>());
-        return;
-
-    case SUBDEV_PROP_GAIN:
-        this->set_tx_gain(val.as<double>(), key.name);
-        return;
-
-    case SUBDEV_PROP_BANDWIDTH:
-        this->set_tx_bandwidth(val.as<double>()/2.0); //complex double-sided, we want low-pass
-        return;
-
-    case SUBDEV_PROP_ANTENNA:
-        this->set_tx_ant(val.as<std::string>());
-        return;
-
-    case SUBDEV_PROP_ENABLED:
-        return; //always enabled
-
-    default: UHD_THROW_PROP_SET_ERROR();
-    }
+    //convert lowpass back to complex bandpass bandwidth
+    return 2.0*_tx_bandwidth;
 }