usrp: populate a tree from a subdev

10 files changed, 540 insertions, 3 deletions

diff --git a/host/include/uhd/types/sensors.hpp b/host/include/uhd/types/sensors.hpp
index 529e1e3e3..a43546262 100644
--- a/host/include/uhd/types/sensors.hpp
+++ b/host/include/uhd/types/sensors.hpp
@@ -37,6 +37,9 @@ namespace uhd{
      */
     struct UHD_API sensor_value_t{
 
+        //! Default constructor
+        sensor_value_t(void);
+
         /*!
          * Create a sensor value from a boolean.
          * \param name the name of the sensor
diff --git a/host/include/uhd/usrp/dboard_eeprom.hpp b/host/include/uhd/usrp/dboard_eeprom.hpp
index 394d71dd6..f0190e233 100644
--- a/host/include/uhd/usrp/dboard_eeprom.hpp
+++ b/host/include/uhd/usrp/dboard_eeprom.hpp
@@ -50,7 +50,7 @@ struct UHD_API dboard_eeprom_t{
      * \param iface the serial interface with i2c
      * \param addr the i2c address for the eeprom
      */
-    void store(i2c_iface &iface, boost::uint8_t addr);
+    void store(i2c_iface &iface, boost::uint8_t addr) const;
 
 };
 
diff --git a/host/include/uhd/usrp/dboard_manager.hpp b/host/include/uhd/usrp/dboard_manager.hpp
index 3c41c65a8..84808ea72 100644
--- a/host/include/uhd/usrp/dboard_manager.hpp
+++ b/host/include/uhd/usrp/dboard_manager.hpp
@@ -19,6 +19,7 @@
 #define INCLUDED_UHD_USRP_DBOARD_MANAGER_HPP
 
 #include <uhd/config.hpp>
+#include <uhd/property_tree.hpp>
 #include <uhd/utils/props.hpp>
 #include <uhd/usrp/dboard_base.hpp>
 #include <uhd/usrp/dboard_id.hpp>
@@ -36,6 +37,13 @@ class UHD_API dboard_manager : boost::noncopyable{
 public:
     typedef boost::shared_ptr<dboard_manager> sptr;
 
+    //! It does what it says...
+    static void populate_prop_tree_from_subdev(
+        property_tree::sptr tree,
+        const property_tree::path_type &root,
+        wax::obj subdev
+    );
+
     //dboard constructor (each dboard should have a ::make with this signature)
     typedef dboard_base::sptr(*dboard_ctor_t)(dboard_base::ctor_args_t);
 
diff --git a/host/lib/types/sensors.cpp b/host/lib/types/sensors.cpp
index 52a63d14c..5e1e8691c 100644
--- a/host/lib/types/sensors.cpp
+++ b/host/lib/types/sensors.cpp
@@ -22,6 +22,13 @@
 
 using namespace uhd;
 
+sensor_value_t::sensor_value_t(void):
+    name(""), value(""),
+    unit(""), type(STRING)
+{
+    /* NOP */
+}
+
 sensor_value_t::sensor_value_t(
     const std::string &name,
     bool value,
diff --git a/host/lib/usrp/dboard_eeprom.cpp b/host/lib/usrp/dboard_eeprom.cpp
index 0dc3471f7..b3cb54c1c 100644
--- a/host/lib/usrp/dboard_eeprom.cpp
+++ b/host/lib/usrp/dboard_eeprom.cpp
@@ -133,7 +133,7 @@ void dboard_eeprom_t::load(i2c_iface &iface, boost::uint8_t addr){
     }
 }
 
-void dboard_eeprom_t::store(i2c_iface &iface, boost::uint8_t addr){
+void dboard_eeprom_t::store(i2c_iface &iface, boost::uint8_t addr) const{
     byte_vector_t bytes(DB_EEPROM_CLEN, 0); //defaults to all zeros
     bytes[DB_EEPROM_MAGIC] = DB_EEPROM_MAGIC_VALUE;
 
diff --git a/host/lib/usrp/dboard_manager.cpp b/host/lib/usrp/dboard_manager.cpp
index 3cc2ca3c0..5b9186a32 100644
--- a/host/lib/usrp/dboard_manager.cpp
+++ b/host/lib/usrp/dboard_manager.cpp
@@ -404,3 +404,121 @@ void dboard_manager_impl::set_nice_dboard_if(void){
         this->get_tx_subdev(sd_name)[SUBDEV_PROP_ENABLED] = false;
     }
 }
+
+/***********************************************************************
+ * Populate a properties tree from a subdev waxy object
+ **********************************************************************/
+#include <uhd/types/ranges.hpp>
+#include <uhd/types/sensors.hpp>
+
+static sensor_value_t get_sensor(wax::obj subdev, const std::string &name){
+    return subdev[named_prop_t(SUBDEV_PROP_SENSOR, name)].as<sensor_value_t>();
+}
+
+static double get_set_gain(wax::obj subdev, const std::string &name, const double gain){
+    subdev[named_prop_t(SUBDEV_PROP_GAIN, name)] = gain;
+    return subdev[named_prop_t(SUBDEV_PROP_GAIN, name)].as<double>();
+}
+
+static meta_range_t get_gain_range(wax::obj subdev, const std::string &name){
+    return subdev[named_prop_t(SUBDEV_PROP_GAIN_RANGE, name)].as<meta_range_t>();
+}
+
+static double get_set_freq(wax::obj subdev, const double freq){
+    subdev[SUBDEV_PROP_FREQ] = freq;
+    return subdev[SUBDEV_PROP_FREQ].as<double>();
+}
+
+static meta_range_t get_freq_range(wax::obj subdev){
+    return subdev[SUBDEV_PROP_FREQ_RANGE].as<meta_range_t>();
+}
+
+static std::string get_set_ant(wax::obj subdev, const std::string &ant){
+    subdev[SUBDEV_PROP_ANTENNA] = ant;
+    return subdev[SUBDEV_PROP_ANTENNA].as<std::string>();
+}
+
+static std::vector<std::string> get_ants(wax::obj subdev){
+    return subdev[SUBDEV_PROP_ANTENNA_NAMES].as<std::vector<std::string> >();
+}
+
+static std::string get_conn(wax::obj subdev){
+    switch(subdev[SUBDEV_PROP_CONNECTION].as<subdev_conn_t>()){
+    case SUBDEV_CONN_COMPLEX_IQ: return "iq";
+    case SUBDEV_CONN_COMPLEX_QI: return "qi";
+    case SUBDEV_CONN_REAL_I: return "i";
+    case SUBDEV_CONN_REAL_Q: return "q";
+    }
+    UHD_THROW_INVALID_CODE_PATH();
+}
+
+static bool get_use_lo_off(wax::obj subdev){
+    return subdev[SUBDEV_PROP_USE_LO_OFFSET].as<bool>();
+}
+
+static bool get_set_enb(wax::obj subdev, const bool enb){
+    subdev[SUBDEV_PROP_ENABLED] = enb;
+    return subdev[SUBDEV_PROP_ENABLED].as<bool>();
+}
+
+static double get_set_bw(wax::obj subdev, const double freq){
+    subdev[SUBDEV_PROP_BANDWIDTH] = freq;
+    return subdev[SUBDEV_PROP_BANDWIDTH].as<double>();
+}
+
+void dboard_manager::populate_prop_tree_from_subdev(
+    property_tree::sptr tree,
+    const property_tree::path_type &root,
+    wax::obj subdev
+){
+    tree->create(root / "name", property<std::string>(subdev[SUBDEV_PROP_NAME].as<std::string>()));
+
+    const prop_names_t sensor_names = subdev[SUBDEV_PROP_SENSOR_NAMES].as<prop_names_t>();
+    BOOST_FOREACH(const std::string &name, sensor_names){
+        property<sensor_value_t> sensor_prop;
+        sensor_prop.publish(boost::bind(&get_sensor, subdev, name));
+        tree->create(root / "sensors" / name, sensor_prop);
+    }
+
+    const prop_names_t gain_names = subdev[SUBDEV_PROP_GAIN_NAMES].as<prop_names_t>();
+    BOOST_FOREACH(const std::string &name, gain_names){
+        property<double> gain_prop;
+        gain_prop.subscribe_master(boost::bind(&get_set_gain, subdev, name, _1));
+        tree->create(root / "gains" / name / "value", gain_prop);
+        property<meta_range_t> gain_range_prop;
+        gain_range_prop.publish(boost::bind(&get_gain_range, subdev, name));
+        tree->create(root / "gains" / name / "range", gain_range_prop);
+    }
+
+    property<double> freq_prop;
+    freq_prop.subscribe_master(boost::bind(&get_set_freq, subdev, _1));
+    tree->create(root / "freq/value", freq_prop);
+
+    property<meta_range_t> freq_range_prop;
+    freq_range_prop.publish(boost::bind(&get_freq_range, subdev));
+    tree->create(root / "freq/range", freq_range_prop);
+
+    property<std::string> ant_prop;
+    ant_prop.subscribe_master(boost::bind(&get_set_ant, subdev, _1));
+    tree->create(root / "antenna/value", ant_prop);
+
+    property<std::vector<std::string> > ants_prop;
+    ants_prop.publish(boost::bind(&get_ants, subdev));
+    tree->create(root / "antenna/options", ants_prop);
+
+    property<std::string> conn_prop;
+    conn_prop.publish(boost::bind(&get_conn, subdev));
+    tree->create(root / "connection", conn_prop);
+
+    property<bool> enb_prop;
+    enb_prop.subscribe_master(boost::bind(&get_set_enb, subdev, _1));
+    tree->create(root / "enabled", enb_prop);
+
+    property<bool> use_lo_off_prop;
+    use_lo_off_prop.publish(boost::bind(&get_use_lo_off, subdev));
+    tree->create(root / "use_lo_offset", use_lo_off_prop);
+
+    property<double> bw_prop;
+    bw_prop.subscribe_master(boost::bind(&get_set_bw, subdev, _1));
+    tree->create(root / "bandwidth/value", bw_prop);
+}
diff --git a/host/lib/usrp2/CMakeLists.txt b/host/lib/usrp2/CMakeLists.txt
index d7d6cc69f..7a0157f00 100644
--- a/host/lib/usrp2/CMakeLists.txt
+++ b/host/lib/usrp2/CMakeLists.txt
@@ -23,6 +23,7 @@ LIBUHD_APPEND_SOURCES(
     ${CMAKE_CURRENT_SOURCE_DIR}/clock_ctrl.hpp
     ${CMAKE_CURRENT_SOURCE_DIR}/codec_ctrl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/codec_ctrl.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/dboard_iface.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/fw_common.h
     ${CMAKE_CURRENT_SOURCE_DIR}/usrp2_iface.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/usrp2_iface.hpp
diff --git a/host/lib/usrp2/dboard_iface.cpp b/host/lib/usrp2/dboard_iface.cpp
new file mode 100644
index 000000000..4ce49b409
--- /dev/null
+++ b/host/lib/usrp2/dboard_iface.cpp
@@ -0,0 +1,350 @@
+//
+// Copyright 2010-2011 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_iface.hpp"
+#include "clock_ctrl.hpp"
+#include "usrp2_regs.hpp" //wishbone address constants
+#include <uhd/usrp/dboard_iface.hpp>
+#include <uhd/types/dict.hpp>
+#include <uhd/exception.hpp>
+#include <uhd/utils/algorithm.hpp>
+#include <boost/assign/list_of.hpp>
+#include <boost/asio.hpp> //htonl and ntohl
+#include <boost/math/special_functions/round.hpp>
+#include "ad7922_regs.hpp" //aux adc
+#include "ad5623_regs.hpp" //aux dac
+
+using namespace uhd;
+using namespace uhd::usrp;
+using namespace boost::assign;
+
+class usrp2_dboard_iface : public dboard_iface{
+public:
+    usrp2_dboard_iface(usrp2_iface::sptr iface, usrp2_clock_ctrl::sptr clock_ctrl);
+    ~usrp2_dboard_iface(void);
+
+    special_props_t get_special_props(void){
+        special_props_t props;
+        props.soft_clock_divider = false;
+        props.mangle_i2c_addrs = false;
+        return props;
+    }
+
+    void write_aux_dac(unit_t, aux_dac_t, double);
+    double read_aux_adc(unit_t, aux_adc_t);
+
+    void _set_pin_ctrl(unit_t, boost::uint16_t);
+    void _set_atr_reg(unit_t, atr_reg_t, boost::uint16_t);
+    void _set_gpio_ddr(unit_t, boost::uint16_t);
+    void _set_gpio_out(unit_t, boost::uint16_t);
+    void set_gpio_debug(unit_t, int);
+    boost::uint16_t read_gpio(unit_t);
+
+    void write_i2c(boost::uint8_t, const byte_vector_t &);
+    byte_vector_t read_i2c(boost::uint8_t, size_t);
+
+    void set_clock_rate(unit_t, double);
+    double get_clock_rate(unit_t);
+    std::vector<double> get_clock_rates(unit_t);
+    void set_clock_enabled(unit_t, bool);
+    double get_codec_rate(unit_t);
+
+    void write_spi(
+        unit_t unit,
+        const spi_config_t &config,
+        boost::uint32_t data,
+        size_t num_bits
+    );
+
+    boost::uint32_t read_write_spi(
+        unit_t unit,
+        const spi_config_t &config,
+        boost::uint32_t data,
+        size_t num_bits
+    );
+
+private:
+    usrp2_iface::sptr _iface;
+    usrp2_clock_ctrl::sptr _clock_ctrl;
+    boost::uint32_t _ddr_shadow;
+    boost::uint32_t _gpio_shadow;
+
+    uhd::dict<unit_t, ad5623_regs_t> _dac_regs;
+    uhd::dict<unit_t, double> _clock_rates;
+    void _write_aux_dac(unit_t);
+};
+
+/***********************************************************************
+ * Make Function
+ **********************************************************************/
+dboard_iface::sptr make_usrp2_dboard_iface(
+    usrp2_iface::sptr iface,
+    usrp2_clock_ctrl::sptr clock_ctrl
+){
+    return dboard_iface::sptr(new usrp2_dboard_iface(iface, clock_ctrl));
+}
+
+/***********************************************************************
+ * Structors
+ **********************************************************************/
+usrp2_dboard_iface::usrp2_dboard_iface(
+    usrp2_iface::sptr iface,
+    usrp2_clock_ctrl::sptr clock_ctrl
+){
+    _iface = iface;
+    _clock_ctrl = clock_ctrl;
+    _ddr_shadow = 0;
+    _gpio_shadow = 0;
+
+    //reset the aux dacs
+    _dac_regs[UNIT_RX] = ad5623_regs_t();
+    _dac_regs[UNIT_TX] = ad5623_regs_t();
+    BOOST_FOREACH(unit_t unit, _dac_regs.keys()){
+        _dac_regs[unit].data = 1;
+        _dac_regs[unit].addr = ad5623_regs_t::ADDR_ALL;
+        _dac_regs[unit].cmd  = ad5623_regs_t::CMD_RESET;
+        this->_write_aux_dac(unit);
+    }
+
+    //init the clock rate shadows with max rate clock
+    this->set_clock_rate(UNIT_RX, sorted(this->get_clock_rates(UNIT_RX)).back());
+    this->set_clock_rate(UNIT_TX, sorted(this->get_clock_rates(UNIT_TX)).back());
+}
+
+usrp2_dboard_iface::~usrp2_dboard_iface(void){
+    /* NOP */
+}
+
+/***********************************************************************
+ * Clocks
+ **********************************************************************/
+void usrp2_dboard_iface::set_clock_rate(unit_t unit, double rate){
+    _clock_rates[unit] = rate; //set to shadow
+    switch(unit){
+    case UNIT_RX: _clock_ctrl->set_rate_rx_dboard_clock(rate); return;
+    case UNIT_TX: _clock_ctrl->set_rate_tx_dboard_clock(rate); return;
+    }
+}
+
+double usrp2_dboard_iface::get_clock_rate(unit_t unit){
+    return _clock_rates[unit]; //get from shadow
+}
+
+std::vector<double> usrp2_dboard_iface::get_clock_rates(unit_t unit){
+    switch(unit){
+    case UNIT_RX: return _clock_ctrl->get_rates_rx_dboard_clock();
+    case UNIT_TX: return _clock_ctrl->get_rates_tx_dboard_clock();
+    default: UHD_THROW_INVALID_CODE_PATH();
+    }
+}
+
+void usrp2_dboard_iface::set_clock_enabled(unit_t unit, bool enb){
+    switch(unit){
+    case UNIT_RX: _clock_ctrl->enable_rx_dboard_clock(enb); return;
+    case UNIT_TX: _clock_ctrl->enable_tx_dboard_clock(enb); return;
+    }
+}
+
+double usrp2_dboard_iface::get_codec_rate(unit_t){
+    return _clock_ctrl->get_master_clock_rate();
+}
+/***********************************************************************
+ * GPIO
+ **********************************************************************/
+static const uhd::dict<dboard_iface::unit_t, int> unit_to_shift = map_list_of
+    (dboard_iface::UNIT_RX, 0)
+    (dboard_iface::UNIT_TX, 16)
+;
+
+void usrp2_dboard_iface::_set_pin_ctrl(unit_t unit, boost::uint16_t value){
+    //calculate the new selection mux setting
+    boost::uint32_t new_sels = 0x0;
+    for(size_t i = 0; i < 16; i++){
+        bool is_bit_set = (value & (0x1 << i)) != 0;
+        new_sels |= ((is_bit_set)? U2_FLAG_GPIO_SEL_ATR : U2_FLAG_GPIO_SEL_GPIO) << (i*2);
+    }
+
+    //write the selection mux value to register
+    switch(unit){
+    case UNIT_RX: _iface->poke32(U2_REG_GPIO_RX_SEL, new_sels); return;
+    case UNIT_TX: _iface->poke32(U2_REG_GPIO_TX_SEL, new_sels); return;
+    }
+}
+
+void usrp2_dboard_iface::_set_gpio_ddr(unit_t unit, boost::uint16_t value){
+    _ddr_shadow = \
+        (_ddr_shadow & ~(0xffff << unit_to_shift[unit])) |
+        (boost::uint32_t(value) << unit_to_shift[unit]);
+    _iface->poke32(U2_REG_GPIO_DDR, _ddr_shadow);
+}
+
+void usrp2_dboard_iface::_set_gpio_out(unit_t unit, boost::uint16_t value){
+    _gpio_shadow = \
+        (_gpio_shadow & ~(0xffff << unit_to_shift[unit])) |
+        (boost::uint32_t(value) << unit_to_shift[unit]);
+    _iface->poke32(U2_REG_GPIO_IO, _gpio_shadow);
+}
+
+boost::uint16_t usrp2_dboard_iface::read_gpio(unit_t unit){
+    return boost::uint16_t(_iface->peek32(U2_REG_GPIO_IO) >> unit_to_shift[unit]);
+}
+
+void usrp2_dboard_iface::_set_atr_reg(unit_t unit, atr_reg_t atr, boost::uint16_t value){
+    //define mapping of unit to atr regs to register address
+    static const uhd::dict<
+        unit_t, uhd::dict<atr_reg_t, boost::uint32_t>
+    > unit_to_atr_to_addr = map_list_of
+        (UNIT_RX, map_list_of
+            (ATR_REG_IDLE,        U2_REG_ATR_IDLE_RXSIDE)
+            (ATR_REG_TX_ONLY,     U2_REG_ATR_INTX_RXSIDE)
+            (ATR_REG_RX_ONLY,     U2_REG_ATR_INRX_RXSIDE)
+            (ATR_REG_FULL_DUPLEX, U2_REG_ATR_FULL_RXSIDE)
+        )
+        (UNIT_TX, map_list_of
+            (ATR_REG_IDLE,        U2_REG_ATR_IDLE_TXSIDE)
+            (ATR_REG_TX_ONLY,     U2_REG_ATR_INTX_TXSIDE)
+            (ATR_REG_RX_ONLY,     U2_REG_ATR_INRX_TXSIDE)
+            (ATR_REG_FULL_DUPLEX, U2_REG_ATR_FULL_TXSIDE)
+        )
+    ;
+    _iface->poke16(unit_to_atr_to_addr[unit][atr], value);
+}
+
+void usrp2_dboard_iface::set_gpio_debug(unit_t unit, int which){
+    this->set_gpio_ddr(unit, 0xffff); //all outputs
+
+    //calculate the new selection mux setting
+    boost::uint32_t new_sels = 0x0;
+    int sel = (which == 0)?
+        U2_FLAG_GPIO_SEL_DEBUG_0:
+        U2_FLAG_GPIO_SEL_DEBUG_1;
+    for(size_t i = 0; i < 16; i++){
+        new_sels |= sel << (i*2);
+    }
+
+    //write the selection mux value to register
+    switch(unit){
+    case UNIT_RX: _iface->poke32(U2_REG_GPIO_RX_SEL, new_sels); return;
+    case UNIT_TX: _iface->poke32(U2_REG_GPIO_TX_SEL, new_sels); return;
+    }
+}
+
+/***********************************************************************
+ * SPI
+ **********************************************************************/
+static const uhd::dict<dboard_iface::unit_t, int> unit_to_spi_dev = map_list_of
+    (dboard_iface::UNIT_TX, SPI_SS_TX_DB)
+    (dboard_iface::UNIT_RX, SPI_SS_RX_DB)
+;
+
+void usrp2_dboard_iface::write_spi(
+    unit_t unit,
+    const spi_config_t &config,
+    boost::uint32_t data,
+    size_t num_bits
+){
+    _iface->write_spi(unit_to_spi_dev[unit], config, data, num_bits);
+}
+
+boost::uint32_t usrp2_dboard_iface::read_write_spi(
+    unit_t unit,
+    const spi_config_t &config,
+    boost::uint32_t data,
+    size_t num_bits
+){
+    return _iface->read_spi(unit_to_spi_dev[unit], config, data, num_bits);
+}
+
+/***********************************************************************
+ * I2C
+ **********************************************************************/
+void usrp2_dboard_iface::write_i2c(boost::uint8_t addr, const byte_vector_t &bytes){
+    return _iface->write_i2c(addr, bytes);
+}
+
+byte_vector_t usrp2_dboard_iface::read_i2c(boost::uint8_t addr, size_t num_bytes){
+    return _iface->read_i2c(addr, num_bytes);
+}
+
+/***********************************************************************
+ * Aux DAX/ADC
+ **********************************************************************/
+void usrp2_dboard_iface::_write_aux_dac(unit_t unit){
+    static const uhd::dict<unit_t, int> unit_to_spi_dac = map_list_of
+        (UNIT_RX, SPI_SS_RX_DAC)
+        (UNIT_TX, SPI_SS_TX_DAC)
+    ;
+    _iface->write_spi(
+        unit_to_spi_dac[unit], spi_config_t::EDGE_FALL, 
+        _dac_regs[unit].get_reg(), 24
+    );
+}
+
+void usrp2_dboard_iface::write_aux_dac(unit_t unit, aux_dac_t which, double value){
+    _dac_regs[unit].data = boost::math::iround(4095*value/3.3);
+    _dac_regs[unit].cmd = ad5623_regs_t::CMD_WR_UP_DAC_CHAN_N;
+
+    typedef uhd::dict<aux_dac_t, ad5623_regs_t::addr_t> aux_dac_to_addr;
+    static const uhd::dict<unit_t, aux_dac_to_addr> unit_to_which_to_addr = map_list_of
+        (UNIT_RX, map_list_of
+            (AUX_DAC_A, ad5623_regs_t::ADDR_DAC_B)
+            (AUX_DAC_B, ad5623_regs_t::ADDR_DAC_A)
+            (AUX_DAC_C, ad5623_regs_t::ADDR_DAC_A)
+            (AUX_DAC_D, ad5623_regs_t::ADDR_DAC_B)
+        )
+        (UNIT_TX, map_list_of
+            (AUX_DAC_A, ad5623_regs_t::ADDR_DAC_A)
+            (AUX_DAC_B, ad5623_regs_t::ADDR_DAC_B)
+            (AUX_DAC_C, ad5623_regs_t::ADDR_DAC_B)
+            (AUX_DAC_D, ad5623_regs_t::ADDR_DAC_A)
+        )
+    ;
+    _dac_regs[unit].addr = unit_to_which_to_addr[unit][which];
+    this->_write_aux_dac(unit);
+}
+
+double usrp2_dboard_iface::read_aux_adc(unit_t unit, aux_adc_t which){
+    static const uhd::dict<unit_t, int> unit_to_spi_adc = map_list_of
+        (UNIT_RX, SPI_SS_RX_ADC)
+        (UNIT_TX, SPI_SS_TX_ADC)
+    ;
+
+    //setup spi config args
+    spi_config_t config;
+    config.mosi_edge = spi_config_t::EDGE_FALL;
+    config.miso_edge = spi_config_t::EDGE_RISE;
+
+    //setup the spi registers
+    ad7922_regs_t ad7922_regs;
+    switch(which){
+    case AUX_ADC_A: ad7922_regs.mod = 0; break;
+    case AUX_ADC_B: ad7922_regs.mod = 1; break;
+    } ad7922_regs.chn = ad7922_regs.mod; //normal mode: mod == chn
+
+    //write and read spi
+    _iface->write_spi(
+        unit_to_spi_adc[unit], config,
+        ad7922_regs.get_reg(), 16
+    );
+    ad7922_regs.set_reg(boost::uint16_t(_iface->read_spi(
+        unit_to_spi_adc[unit], config,
+        ad7922_regs.get_reg(), 16
+    )));
+
+    //convert to voltage and return
+    return 3.3*ad7922_regs.result/4095;
+}
diff --git a/host/lib/usrp2/usrp2_impl.cpp b/host/lib/usrp2/usrp2_impl.cpp
index 1ffcae626..53e0c51ac 100644
--- a/host/lib/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp2/usrp2_impl.cpp
@@ -23,7 +23,6 @@
 #include <uhd/transport/if_addrs.hpp>
 #include <uhd/transport/udp_zero_copy.hpp>
 #include <uhd/types/ranges.hpp>
-#include <uhd/usrp/device_props.hpp>
 #include <uhd/exception.hpp>
 #include <uhd/utils/static.hpp>
 #include <uhd/utils/byteswap.hpp>
@@ -281,6 +280,7 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr){
         _mboard_stuff[mb].tx_fe = tx_frontend_core_200::make(
             _mboard_stuff[mb].iface, U2_REG_SR_ADDR(SR_TX_FRONT)
         );
+        //TODO lots of properties to expose here for frontends
 
         ////////////////////////////////////////////////////////////////
         // create dsp control objects
@@ -310,6 +310,7 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr){
         _tree->create(mb_path / "tx_dsps/0/rate/value", tx_dsp_host_rate_prop);
         tx_dsp_freq_prop.subscribe_master(boost::bind(&tx_dsp_core_200::set_freq, _mboard_stuff[mb].tx_dsp, _1));
         _tree->create(mb_path / "tx_dsps/0/freq/value", tx_dsp_freq_prop);
+        //TODO combine w/ codec shift
         //setup dsp flow control
         const double ups_per_sec = device_args[mb].cast<double>("ups_per_sec", 20);
         const size_t send_frame_size = _mboard_stuff[mb].dsp_xports.front()->get_send_frame_size();
@@ -339,6 +340,46 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr){
         time_pps_prop.subscribe(boost::bind(&time64_core_200::set_time_next_pps, _mboard_stuff[mb].time64, _1));
         _tree->create(mb_path / "time/pps", time_pps_prop);
 
+        ////////////////////////////////////////////////////////////////
+        // create dboard control objects
+        ////////////////////////////////////////////////////////////////
+
+        //read the dboard eeprom to extract the dboard ids
+        dboard_eeprom_t rx_db_eeprom, tx_db_eeprom, gdb_eeprom;
+        rx_db_eeprom.load(*_mboard_stuff[mb].iface, USRP2_I2C_ADDR_RX_DB);
+        tx_db_eeprom.load(*_mboard_stuff[mb].iface, USRP2_I2C_ADDR_TX_DB);
+        gdb_eeprom.load(*_mboard_stuff[mb].iface, USRP2_I2C_ADDR_TX_DB ^ 5);
+
+        //create the properties and register subscribers
+        property<dboard_eeprom_t> rx_db_eeprom_prop(rx_db_eeprom), tx_db_eeprom_prop(tx_db_eeprom), gdb_eeprom_prop(gdb_eeprom);
+        rx_db_eeprom_prop.subscribe(boost::bind(&usrp2_impl::set_db_eeprom, this, mb, "rx", _1));
+        _tree->create(mb_path / "dboards/0/rx_eeprom", rx_db_eeprom_prop);
+        tx_db_eeprom_prop.subscribe(boost::bind(&usrp2_impl::set_db_eeprom, this, mb, "tx", _1));
+        _tree->create(mb_path / "dboards/0/tx_eeprom", tx_db_eeprom_prop);
+        gdb_eeprom_prop.subscribe(boost::bind(&usrp2_impl::set_db_eeprom, this, mb, "gdb", _1));
+        _tree->create(mb_path / "dboards/0/gdb_eeprom", gdb_eeprom_prop);
+
+        //create a new dboard interface and manager
+        _mboard_stuff[mb].dboard_iface = make_usrp2_dboard_iface(_mboard_stuff[mb].iface, _mboard_stuff[mb].clock);
+        _tree->create(mb_path / "dboards/0/iface", property<dboard_iface::sptr>(_mboard_stuff[mb].dboard_iface));
+        _mboard_stuff[mb].dboard_manager = dboard_manager::make(
+            rx_db_eeprom.id,
+            ((gdb_eeprom.id == dboard_id_t::none())? tx_db_eeprom : gdb_eeprom).id,
+            _mboard_stuff[mb].dboard_iface
+        );
+        BOOST_FOREACH(const std::string &name, _mboard_stuff[mb].dboard_manager->get_rx_subdev_names()){
+            dboard_manager::populate_prop_tree_from_subdev(
+                _tree, mb_path / "rx_rf_frontends" / name,
+                _mboard_stuff[mb].dboard_manager->get_rx_subdev(name)
+            );
+        }
+        BOOST_FOREACH(const std::string &name, _mboard_stuff[mb].dboard_manager->get_tx_subdev_names()){
+            dboard_manager::populate_prop_tree_from_subdev(
+                _tree, mb_path / "tx_rf_frontends" / name,
+                _mboard_stuff[mb].dboard_manager->get_tx_subdev(name)
+            );
+        }
+
     }
 
 }
@@ -352,3 +393,9 @@ usrp2_impl::~usrp2_impl(void){UHD_SAFE_CALL(
 void usrp2_impl::set_mb_eeprom(const size_t which_mb, const uhd::usrp::mboard_eeprom_t &mb_eeprom){
     mb_eeprom.commit(*(_mboard_stuff[which_mb].iface), mboard_eeprom_t::MAP_N100);
 }
+
+void usrp2_impl::set_db_eeprom(const size_t which_mb, const std::string &type, const uhd::usrp::dboard_eeprom_t &db_eeprom){
+    if (type == "rx") db_eeprom.store(*_mboard_stuff[which_mb].iface, USRP2_I2C_ADDR_RX_DB);
+    if (type == "tx") db_eeprom.store(*_mboard_stuff[which_mb].iface, USRP2_I2C_ADDR_TX_DB);
+    if (type == "gdb") db_eeprom.store(*_mboard_stuff[which_mb].iface, USRP2_I2C_ADDR_TX_DB ^ 5);
+}
diff --git a/host/lib/usrp2/usrp2_impl.hpp b/host/lib/usrp2/usrp2_impl.hpp
index 19f1d8b0f..fe82af40a 100644
--- a/host/lib/usrp2/usrp2_impl.hpp
+++ b/host/lib/usrp2/usrp2_impl.hpp
@@ -81,10 +81,13 @@ private:
         time64_core_200::sptr time64;
         std::vector<uhd::transport::zero_copy_if::sptr> dsp_xports;
         std::vector<uhd::transport::zero_copy_if::sptr> err_xports;
+        uhd::usrp::dboard_manager::sptr dboard_manager;
+        uhd::usrp::dboard_iface::sptr dboard_iface;
     };
     std::vector<mboard_stuff_type> _mboard_stuff;
 
     void set_mb_eeprom(const size_t which_mb, const uhd::usrp::mboard_eeprom_t &mb_eeprom);
+    void set_db_eeprom(const size_t which_mb, const std::string &type, const uhd::usrp::dboard_eeprom_t &db_eeprom);
 
 };