moved host code into host directory for clean (unambiguous) top level

17 files changed, 1677 insertions, 0 deletions

diff --git a/host/lib/usrp/dboard/base.cpp b/host/lib/usrp/dboard/base.cpp
new file mode 100644
index 000000000..de8db323a
--- /dev/null
+++ b/host/lib/usrp/dboard/base.cpp
@@ -0,0 +1,89 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/dboard/base.hpp>
+#include <stdexcept>
+
+using namespace uhd::usrp::dboard;
+
+/***********************************************************************
+ * base dboard base class
+ **********************************************************************/
+base::base(ctor_args_t const& args){
+    boost::tie(_subdev_name, _dboard_interface) = args;
+}
+
+base::~base(void){
+    /* NOP */
+}
+
+std::string base::get_subdev_name(void){
+    return _subdev_name;
+}
+
+interface::sptr base::get_interface(void){
+    return _dboard_interface;
+}
+
+/***********************************************************************
+ * xcvr dboard base class
+ **********************************************************************/
+xcvr_base::xcvr_base(ctor_args_t const& args) : base(args){
+    /* NOP */
+}
+
+xcvr_base::~xcvr_base(void){
+    /* NOP */
+}
+
+/***********************************************************************
+ * rx dboard base class
+ **********************************************************************/
+rx_base::rx_base(ctor_args_t const& args) : base(args){
+    /* NOP */
+}
+
+rx_base::~rx_base(void){
+    /* NOP */
+}
+
+void rx_base::tx_get(const wax::obj &, wax::obj &){
+    throw std::runtime_error("cannot call tx_get on a rx dboard");
+}
+
+void rx_base::tx_set(const wax::obj &, const wax::obj &){
+    throw std::runtime_error("cannot call tx_set on a rx dboard");
+}
+
+/***********************************************************************
+ * tx dboard base class
+ **********************************************************************/
+tx_base::tx_base(ctor_args_t const& args) : base(args){
+    /* NOP */
+}
+
+tx_base::~tx_base(void){
+    /* NOP */
+}
+
+void tx_base::rx_get(const wax::obj &, wax::obj &){
+    throw std::runtime_error("cannot call rx_get on a tx dboard");
+}
+
+void tx_base::rx_set(const wax::obj &, const wax::obj &){
+    throw std::runtime_error("cannot call rx_set on a tx dboard");
+}
diff --git a/host/lib/usrp/dboard/basic.cpp b/host/lib/usrp/dboard/basic.cpp
new file mode 100644
index 000000000..35512aa5f
--- /dev/null
+++ b/host/lib/usrp/dboard/basic.cpp
@@ -0,0 +1,56 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "dboards.hpp"
+
+/***********************************************************************
+ * Basic RX dboard
+ **********************************************************************/
+basic_rx::basic_rx(ctor_args_t const& args) : rx_base(args){
+    /* NOP */
+}
+
+basic_rx::~basic_rx(void){
+    /* NOP */
+}
+
+void basic_rx::rx_get(const wax::obj &, wax::obj &){
+    /* TODO */
+}
+
+void basic_rx::rx_set(const wax::obj &, const wax::obj &){
+    /* TODO */
+}
+
+/***********************************************************************
+ * Basic TX dboard
+ **********************************************************************/
+basic_tx::basic_tx(ctor_args_t const& args) : tx_base(args){
+    /* NOP */
+}
+
+basic_tx::~basic_tx(void){
+    /* NOP */
+}
+
+void basic_tx::tx_get(const wax::obj &, wax::obj &){
+    /* TODO */
+}
+
+void basic_tx::tx_set(const wax::obj &, const wax::obj &){
+    /* TODO */
+}
diff --git a/host/lib/usrp/dboard/dboards.hpp b/host/lib/usrp/dboard/dboards.hpp
new file mode 100644
index 000000000..0e740856f
--- /dev/null
+++ b/host/lib/usrp/dboard/dboards.hpp
@@ -0,0 +1,53 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_LOCAL_DBOARDS_HPP
+#define INCLUDED_LOCAL_DBOARDS_HPP
+
+#include <uhd/usrp/dboard/base.hpp>
+
+using namespace uhd::usrp::dboard;
+
+/***********************************************************************
+ * The basic boards:
+ **********************************************************************/
+class basic_rx : public rx_base{
+public:
+    static base::sptr make(ctor_args_t const& args){
+        return base::sptr(new basic_rx(args));
+    }
+    basic_rx(ctor_args_t const& args);
+    ~basic_rx(void);
+
+    void rx_get(const wax::obj &key, wax::obj &val);
+    void rx_set(const wax::obj &key, const wax::obj &val);
+};
+
+class basic_tx : public tx_base{
+public:
+    static base::sptr make(ctor_args_t const& args){
+        return base::sptr(new basic_tx(args));
+    }
+    basic_tx(ctor_args_t const& args);
+    ~basic_tx(void);
+
+    void tx_get(const wax::obj &key, wax::obj &val);
+    void tx_set(const wax::obj &key, const wax::obj &val);
+
+};
+
+#endif /* INCLUDED_LOCAL_DBOARDS_HPP */
diff --git a/host/lib/usrp/dboard/id.cpp b/host/lib/usrp/dboard/id.cpp
new file mode 100644
index 000000000..80162240e
--- /dev/null
+++ b/host/lib/usrp/dboard/id.cpp
@@ -0,0 +1,39 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/dboard/id.hpp>
+#include <boost/format.hpp>
+#include <uhd/dict.hpp>
+
+using namespace uhd::usrp::dboard;
+
+std::ostream& operator<<(std::ostream &os, const dboard_id_t &id){
+    //map the dboard ids to string representations
+    uhd::dict<dboard_id_t, std::string> id_to_str;
+    id_to_str[ID_NONE]     = "none";
+    id_to_str[ID_BASIC_TX] = "basic tx";
+    id_to_str[ID_BASIC_RX] = "basic rx";
+
+    //get the string representation
+    if (id_to_str.has_key(id)){
+        os << id_to_str[id];
+    }
+    else{
+        os << boost::format("dboard id %u") % unsigned(id);
+    }
+    return os;
+}
diff --git a/host/lib/usrp/dboard/interface.cpp b/host/lib/usrp/dboard/interface.cpp
new file mode 100644
index 000000000..837c76d0a
--- /dev/null
+++ b/host/lib/usrp/dboard/interface.cpp
@@ -0,0 +1,28 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/dboard/interface.hpp>
+
+using namespace uhd::usrp::dboard;
+
+interface::interface(void){
+    /* NOP */
+}
+
+interface::~interface(void){
+    /* NOP */
+}
diff --git a/host/lib/usrp/dboard/manager.cpp b/host/lib/usrp/dboard/manager.cpp
new file mode 100644
index 000000000..4a675fd0b
--- /dev/null
+++ b/host/lib/usrp/dboard/manager.cpp
@@ -0,0 +1,205 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/dboard/manager.hpp>
+#include <boost/assign/list_of.hpp>
+#include <boost/format.hpp>
+#include <boost/foreach.hpp>
+#include "dboards.hpp"
+
+using namespace uhd;
+using namespace uhd::usrp::dboard;
+using namespace boost::assign;
+
+/***********************************************************************
+ * register internal dboards
+ *
+ * Register internal/known dboards located in this build tree.
+ * Each board should have entries below mapping an id to a constructor.
+ * The xcvr type boards should register both rx and tx sides.
+ *
+ * This function will be called before new boards are registered.
+ * This allows for internal boards to be externally overridden.
+ * This function will also be called when creating a new manager
+ * to ensure that the maps are filled with the entries below.
+ **********************************************************************/
+static void register_internal_dboards(void){
+    //ensure that this function can only be called once per instance
+    static bool called = false;
+    if (called) return; called = true;
+    //register the known dboards (dboard id, constructor, subdev names)
+    manager::register_subdevs(ID_NONE,     &basic_tx::make, list_of(""));   //for none, make a basic tx
+    manager::register_subdevs(ID_NONE,     &basic_rx::make, list_of("ab")); //for none, make a basic rx (one subdev)
+    manager::register_subdevs(ID_BASIC_TX, &basic_tx::make, list_of(""));
+    manager::register_subdevs(ID_BASIC_RX, &basic_rx::make, list_of("a")("b")("ab"));
+}
+
+/***********************************************************************
+ * storage and registering for dboards
+ **********************************************************************/
+//map a dboard id to a dboard constructor
+static uhd::dict<dboard_id_t, manager::dboard_ctor_t> id_to_ctor_map;
+
+//map a dboard constructor to subdevice names
+static uhd::dict<manager::dboard_ctor_t, prop_names_t> ctor_to_names_map;
+
+void manager::register_subdevs(
+    dboard_id_t dboard_id,
+    dboard_ctor_t dboard_ctor,
+    const prop_names_t &subdev_names
+){
+    register_internal_dboards(); //always call first
+    id_to_ctor_map[dboard_id] = dboard_ctor;
+    ctor_to_names_map[dboard_ctor] = subdev_names;
+}
+
+/***********************************************************************
+ * internal helper classes
+ **********************************************************************/
+/*!
+ * A special wax proxy object that forwards calls to a subdev.
+ * A sptr to an instance will be used in the properties structure. 
+ */
+class subdev_proxy : boost::noncopyable, public wax::obj{
+public:
+    typedef boost::shared_ptr<subdev_proxy> sptr;
+    enum type_t{RX_TYPE, TX_TYPE};
+
+    //structors
+    subdev_proxy(base::sptr subdev, type_t type)
+    : _subdev(subdev), _type(type){
+        /* NOP */
+    }
+
+    ~subdev_proxy(void){
+        /* NOP */
+    }
+
+private:
+    base::sptr   _subdev;
+    type_t       _type;
+
+    //forward the get calls to the rx or tx
+    void get(const wax::obj &key, wax::obj &val){
+        switch(_type){
+        case RX_TYPE: return _subdev->rx_get(key, val);
+        case TX_TYPE: return _subdev->tx_get(key, val);
+        }
+    }
+
+    //forward the set calls to the rx or tx
+    void set(const wax::obj &key, const wax::obj &val){
+        switch(_type){
+        case RX_TYPE: return _subdev->rx_set(key, val);
+        case TX_TYPE: return _subdev->tx_set(key, val);
+        }
+    }
+};
+
+/***********************************************************************
+ * dboard manager methods
+ **********************************************************************/
+static manager::dboard_ctor_t const& get_dboard_ctor(
+    dboard_id_t dboard_id,
+    std::string const& xx_type
+){
+    //verify that there is a registered constructor for this id
+    if (not id_to_ctor_map.has_key(dboard_id)){
+        throw std::runtime_error(str(
+            boost::format("Unknown %s dboard id: 0x%04x") % xx_type % dboard_id
+        ));
+    }
+    //return the dboard constructor for this id
+    return id_to_ctor_map[dboard_id];
+}
+
+manager::manager(
+    dboard_id_t rx_dboard_id,
+    dboard_id_t tx_dboard_id,
+    interface::sptr dboard_interface
+){
+    register_internal_dboards(); //always call first
+    const dboard_ctor_t rx_dboard_ctor = get_dboard_ctor(rx_dboard_id, "rx");
+    const dboard_ctor_t tx_dboard_ctor = get_dboard_ctor(tx_dboard_id, "tx");
+    //make xcvr subdevs (make one subdev for both rx and tx dboards)
+    if (rx_dboard_ctor == tx_dboard_ctor){
+        BOOST_FOREACH(std::string name, ctor_to_names_map[rx_dboard_ctor]){
+            base::sptr xcvr_dboard = rx_dboard_ctor(
+                base::ctor_args_t(name, dboard_interface)
+            );
+            //create a rx proxy for this xcvr board
+            _rx_dboards[name] = subdev_proxy::sptr(
+                new subdev_proxy(xcvr_dboard, subdev_proxy::RX_TYPE)
+            );
+            //create a tx proxy for this xcvr board
+            _tx_dboards[name] = subdev_proxy::sptr(
+                new subdev_proxy(xcvr_dboard, subdev_proxy::TX_TYPE)
+            );
+        }
+    }
+    //make tx and rx subdevs (separate subdevs for rx and tx dboards)
+    else{
+        //make the rx subdevs
+        BOOST_FOREACH(std::string name, ctor_to_names_map[rx_dboard_ctor]){
+            base::sptr rx_dboard = rx_dboard_ctor(
+                base::ctor_args_t(name, dboard_interface)
+            );
+            //create a rx proxy for this rx board
+            _rx_dboards[name] = subdev_proxy::sptr(
+                new subdev_proxy(rx_dboard, subdev_proxy::RX_TYPE)
+            );
+        }
+        //make the tx subdevs
+        BOOST_FOREACH(std::string name, ctor_to_names_map[tx_dboard_ctor]){
+            base::sptr tx_dboard = tx_dboard_ctor(
+                base::ctor_args_t(name, dboard_interface)
+            );
+            //create a tx proxy for this tx board
+            _tx_dboards[name] = subdev_proxy::sptr(
+                new subdev_proxy(tx_dboard, subdev_proxy::TX_TYPE)
+            );
+        }
+    }
+}
+
+manager::~manager(void){
+    /* NOP */
+}
+
+prop_names_t manager::get_rx_subdev_names(void){
+    return _rx_dboards.get_keys();
+}
+
+prop_names_t manager::get_tx_subdev_names(void){
+    return _tx_dboards.get_keys();
+}
+
+wax::obj manager::get_rx_subdev(const std::string &subdev_name){
+    if (not _rx_dboards.has_key(subdev_name)) throw std::invalid_argument(
+        str(boost::format("Unknown rx subdev name %s") % subdev_name)
+    );
+    //get a link to the rx subdev proxy
+    return wax::cast<subdev_proxy::sptr>(_rx_dboards[subdev_name])->get_link();
+}
+
+wax::obj manager::get_tx_subdev(const std::string &subdev_name){
+    if (not _tx_dboards.has_key(subdev_name)) throw std::invalid_argument(
+        str(boost::format("Unknown tx subdev name %s") % subdev_name)
+    );
+    //get a link to the tx subdev proxy
+    return wax::cast<subdev_proxy::sptr>(_tx_dboards[subdev_name])->get_link();
+}
diff --git a/host/lib/usrp/mboard/base.cpp b/host/lib/usrp/mboard/base.cpp
new file mode 100644
index 000000000..f4f0324f3
--- /dev/null
+++ b/host/lib/usrp/mboard/base.cpp
@@ -0,0 +1,29 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/mboard/base.hpp>
+#include <stdexcept>
+
+using namespace uhd::usrp::mboard;
+
+base::base(void){
+    /* NOP */
+}
+
+base::~base(void){
+    /* NOP */
+}
diff --git a/host/lib/usrp/mboard/test.cpp b/host/lib/usrp/mboard/test.cpp
new file mode 100644
index 000000000..67d3c70fa
--- /dev/null
+++ b/host/lib/usrp/mboard/test.cpp
@@ -0,0 +1,188 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/mboard/test.hpp>
+#include <uhd/props.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/format.hpp>
+#include <stdexcept>
+
+using namespace uhd;
+using namespace uhd::usrp;
+using namespace uhd::usrp::mboard;
+
+/***********************************************************************
+ * dummy interface for dboards
+ **********************************************************************/
+class dummy_interface : public uhd::usrp::dboard::interface{
+public:
+    dummy_interface(void){}
+    ~dummy_interface(void){}
+    void write_aux_dac(int, int){}
+    int read_aux_adc(int){return 0;}
+    void set_atr_reg(gpio_bank_t, uint16_t, uint16_t, uint16_t){}
+    void set_gpio_ddr(gpio_bank_t, uint16_t, uint16_t){}
+    void write_gpio(gpio_bank_t, uint16_t, uint16_t){}
+    uint16_t read_gpio(gpio_bank_t){return 0;}
+    void write_i2c (int, const std::string &){}
+    std::string read_i2c (int, size_t){return "";}
+    void write_spi (spi_dev_t, spi_push_t, const std::string &){}
+    std::string read_spi (spi_dev_t, spi_latch_t, size_t){return "";}
+    double get_rx_clock_rate(void){return 0.0;}
+    double get_tx_clock_rate(void){return 0.0;}
+};
+
+/***********************************************************************
+ * shell class to act as a dboard
+ **********************************************************************/
+class shell_dboard : public wax::obj{
+public:
+    enum type_t {TYPE_RX, TYPE_TX};
+    shell_dboard(dboard::manager::sptr mgr, type_t type){
+        _mgr = mgr;
+        _type = type;
+    }
+    ~shell_dboard(void){}
+private:
+    void get(const wax::obj &key_, wax::obj &val){
+        wax::obj key; std::string name;
+        boost::tie(key, name) = extract_named_prop(key_);
+
+        //handle the get request conditioned on the key
+        switch(wax::cast<dboard_prop_t>(key)){
+        case DBOARD_PROP_NAME:
+            val = std::string("dboard test mboard");
+            return;
+
+        case DBOARD_PROP_SUBDEV:
+            switch(_type){
+            case TYPE_RX:
+                val = _mgr->get_rx_subdev(name);
+                return;
+
+            case TYPE_TX:
+                val = _mgr->get_tx_subdev(name);
+                return;
+            }
+
+        case DBOARD_PROP_SUBDEV_NAMES:
+            switch(_type){
+            case TYPE_RX:
+                val = _mgr->get_rx_subdev_names();
+                return;
+
+            case TYPE_TX:
+                val = _mgr->get_tx_subdev_names();
+                return;
+            }
+
+        case DBOARD_PROP_CODEC:
+            return;
+        }
+    }
+
+    void set(const wax::obj &, const wax::obj &){
+        throw std::runtime_error("Cannot set on usrp test dboard");
+    }
+
+    type_t                _type;
+    dboard::manager::sptr _mgr;
+};
+
+/***********************************************************************
+ * test usrp mboard class
+ **********************************************************************/
+test::test(const device_addr_t &device_addr){
+    //extract the number of dboards
+    size_t num_dboards = boost::lexical_cast<size_t>(device_addr["num_dboards"]);
+    //create a manager for each dboard
+    for (size_t i = 0; i < num_dboards; i++){
+        dboard::interface::sptr ifc(new dummy_interface());
+        _dboard_managers[boost::lexical_cast<std::string>(i)] = dboard::manager::sptr(
+            new dboard::manager(dboard::ID_BASIC_RX, dboard::ID_BASIC_TX, ifc)
+        );
+    }
+}
+
+test::~test(void){
+    /* NOP */
+}
+
+void test::get(const wax::obj &key_, wax::obj &val){
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+
+    //handle the get request conditioned on the key
+    switch(wax::cast<mboard_prop_t>(key)){
+    case MBOARD_PROP_NAME:
+        val = std::string("usrp test mboard");
+        return;
+
+    case MBOARD_PROP_OTHERS:
+        val = prop_names_t(); //empty other props
+        return;
+
+    case MBOARD_PROP_RX_DBOARD:
+        if (not _dboard_managers.has_key(name)) throw std::invalid_argument(
+            str(boost::format("Unknown rx dboard name %s") % name)
+        );
+        //FIXME store the shell dboard within the class
+        //may not fix, plan to remove this test class when real usrps work
+        //val = wax::obj::sptr(
+        //    new shell_dboard(_dboard_managers[name], shell_dboard::TYPE_RX)
+        //);
+        return;
+
+    case MBOARD_PROP_RX_DBOARD_NAMES:
+        val = prop_names_t(_dboard_managers.get_keys());
+        return;
+
+    case MBOARD_PROP_TX_DBOARD:
+        if (not _dboard_managers.has_key(name)) throw std::invalid_argument(
+            str(boost::format("Unknown tx dboard name %s") % name)
+        );
+        //FIXME store the shell dboard within the class
+        //may not fix, plan to remove this test class when real usrps work
+        //val = wax::obj::sptr(
+        //    new shell_dboard(_dboard_managers[name], shell_dboard::TYPE_TX)
+        //);
+        return;
+
+    case MBOARD_PROP_TX_DBOARD_NAMES:
+        val = prop_names_t(_dboard_managers.get_keys());
+        return;
+
+    case MBOARD_PROP_MTU:
+    case MBOARD_PROP_CLOCK_RATE:
+    case MBOARD_PROP_RX_DSP:
+    case MBOARD_PROP_RX_DSP_NAMES:
+    case MBOARD_PROP_TX_DSP:
+    case MBOARD_PROP_TX_DSP_NAMES:
+    case MBOARD_PROP_PPS_SOURCE:
+    case MBOARD_PROP_PPS_SOURCE_NAMES:
+    case MBOARD_PROP_PPS_POLARITY:
+    case MBOARD_PROP_REF_SOURCE:
+    case MBOARD_PROP_REF_SOURCE_NAMES:
+    case MBOARD_PROP_TIME_NOW:
+    case MBOARD_PROP_TIME_NEXT_PPS:
+        throw std::runtime_error("unhandled prop is usrp test mboard");
+    }
+}
+
+void test::set(const wax::obj &, const wax::obj &){
+    throw std::runtime_error("Cannot set on usrp test mboard");
+}
diff --git a/host/lib/usrp/mboard/usrp2.cpp b/host/lib/usrp/mboard/usrp2.cpp
new file mode 100644
index 000000000..92f4daa49
--- /dev/null
+++ b/host/lib/usrp/mboard/usrp2.cpp
@@ -0,0 +1,116 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/mboard/usrp2.hpp>
+#include <uhd/device.hpp>
+#include <uhd/transport/udp.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/format.hpp>
+#include <boost/thread.hpp>
+#include <netinet/in.h>
+#include "usrp2/impl_base.hpp"
+
+using namespace uhd::usrp::mboard;
+
+/***********************************************************************
+ * Discovery over the udp transport
+ **********************************************************************/
+uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){
+    device_addrs_t usrp2_addrs;
+
+    //create a udp transport to communicate
+    //TODO if an addr is not provided, search all interfaces?
+    std::string ctrl_port = boost::lexical_cast<std::string>(USRP2_UDP_CTRL_PORT);
+    uhd::transport::udp udp_transport(hint["addr"], ctrl_port, true);
+
+    //send a hello control packet
+    usrp2_ctrl_data_t ctrl_data_out;
+    ctrl_data_out.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_IP_ADDR_BRO);
+    udp_transport.send(boost::asio::buffer(&ctrl_data_out, sizeof(ctrl_data_out)));
+
+    //loop and recieve until the time is up
+    size_t num_timeouts = 0;
+    while(true){
+        uhd::shared_iovec iov = udp_transport.recv();
+        //std::cout << boost::asio::buffer_size(buff) << "\n";
+        if (iov.len < sizeof(usrp2_ctrl_data_t)){
+            //sleep a little so we dont burn cpu
+            if (num_timeouts++ > 50) break;
+            boost::this_thread::sleep(boost::posix_time::milliseconds(1));
+        }else{
+            //handle the received data
+            const usrp2_ctrl_data_t *ctrl_data_in = reinterpret_cast<const usrp2_ctrl_data_t *>(iov.base);
+            switch(ntohl(ctrl_data_in->id)){
+            case USRP2_CTRL_ID_THIS_IS_MY_IP_ADDR_DUDE:
+                //make a boost asio ipv4 with the raw addr in host byte order
+                boost::asio::ip::address_v4 ip_addr(ntohl(ctrl_data_in->data.ip_addr));
+                device_addr_t new_addr;
+                new_addr["name"] = "USRP2";
+                new_addr["type"] = "udp";
+                new_addr["addr"] = ip_addr.to_string();
+                usrp2_addrs.push_back(new_addr);
+                break;
+            }
+        }
+    }
+
+    return usrp2_addrs;
+}
+
+/***********************************************************************
+ * Structors
+ **********************************************************************/
+usrp2::usrp2(const device_addr_t &device_addr){
+    //create a control transport
+    uhd::transport::udp::sptr ctrl_transport(
+        new uhd::transport::udp(
+            device_addr["addr"],
+            boost::lexical_cast<std::string>(USRP2_UDP_CTRL_PORT)
+        )
+    );
+
+    //create a data transport
+    uhd::transport::udp::sptr data_transport(
+        new uhd::transport::udp(
+            device_addr["addr"],
+            boost::lexical_cast<std::string>(USRP2_UDP_DATA_PORT)
+        )
+    );
+
+    //create the usrp2 implementation guts
+    _impl = impl_base::sptr(
+        new impl_base(ctrl_transport, data_transport)
+    );
+}
+
+usrp2::~usrp2(void){
+    /* NOP */
+}
+
+/***********************************************************************
+ * Get Properties
+ **********************************************************************/
+void usrp2::get(const wax::obj &key, wax::obj &val){
+    return wax::cast<impl_base::sptr>(_impl)->get(key, val);
+}
+
+/***********************************************************************
+ * Set Properties
+ **********************************************************************/
+void usrp2::set(const wax::obj &key, const wax::obj &val){
+    return wax::cast<impl_base::sptr>(_impl)->set(key, val);
+}
diff --git a/host/lib/usrp/mboard/usrp2/dboard_impl.cpp b/host/lib/usrp/mboard/usrp2/dboard_impl.cpp
new file mode 100644
index 000000000..309335cc7
--- /dev/null
+++ b/host/lib/usrp/mboard/usrp2/dboard_impl.cpp
@@ -0,0 +1,76 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <boost/format.hpp>
+#include <uhd/utils.hpp>
+#include <uhd/props.hpp>
+#include <iostream>
+#include "dboard_impl.hpp"
+#include "dboard_interface.hpp"
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+dboard_impl::dboard_impl(uhd::usrp::dboard::manager::sptr mgr, type_t type){
+    _mgr = mgr;
+    _type = type;
+}
+
+dboard_impl::~dboard_impl(void){
+    /* NOP */
+}
+
+void dboard_impl::get(const wax::obj &key_, wax::obj &val){
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+
+    //handle the get request conditioned on the key
+    switch(wax::cast<dboard_prop_t>(key)){
+    case DBOARD_PROP_NAME:
+        val = std::string("usrp2 dboard");
+        return;
+
+    case DBOARD_PROP_SUBDEV:
+        switch(_type){
+        case TYPE_RX:
+            val = _mgr->get_rx_subdev(name);
+            return;
+
+        case TYPE_TX:
+            val = _mgr->get_tx_subdev(name);
+            return;
+        }
+
+    case DBOARD_PROP_SUBDEV_NAMES:
+        switch(_type){
+        case TYPE_RX:
+            val = _mgr->get_rx_subdev_names();
+            return;
+
+        case TYPE_TX:
+            val = _mgr->get_tx_subdev_names();
+            return;
+        }
+
+    case DBOARD_PROP_CODEC:
+        throw std::runtime_error("unhandled prop in usrp2 dboard");
+    }
+}
+
+void dboard_impl::set(const wax::obj &, const wax::obj &){
+    throw std::runtime_error("Cannot set on usrp2 dboard");
+}
diff --git a/host/lib/usrp/mboard/usrp2/dboard_impl.hpp b/host/lib/usrp/mboard/usrp2/dboard_impl.hpp
new file mode 100644
index 000000000..a05bcd07b
--- /dev/null
+++ b/host/lib/usrp/mboard/usrp2/dboard_impl.hpp
@@ -0,0 +1,50 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/dboard/manager.hpp>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+#include "fw_common.h"
+
+#ifndef INCLUDED_DBOARD_IMPL_HPP
+#define INCLUDED_DBOARD_IMPL_HPP
+
+/*!
+ * The usrp2 dboard implementation:
+ * Provide the properties access for a dboard.
+ * Internally, hold a dboard manager and the direction.
+ * The usrp2 mboard base implementation will create
+ * two of these classes (one for rx and one for tx).
+ */
+class dboard_impl : boost::noncopyable, public wax::obj{
+public:
+    typedef boost::shared_ptr<dboard_impl> sptr;
+    enum type_t {TYPE_RX, TYPE_TX};
+
+    dboard_impl(uhd::usrp::dboard::manager::sptr manager, type_t type);
+    
+    ~dboard_impl(void);
+
+    void get(const wax::obj &, wax::obj &);
+    void set(const wax::obj &, const wax::obj &);
+
+private:
+    uhd::usrp::dboard::manager::sptr   _mgr;
+    type_t                             _type;
+};
+
+#endif /* INCLUDED_DBOARD_IMPL_HPP */
diff --git a/host/lib/usrp/mboard/usrp2/dboard_interface.cpp b/host/lib/usrp/mboard/usrp2/dboard_interface.cpp
new file mode 100644
index 000000000..05d29daef
--- /dev/null
+++ b/host/lib/usrp/mboard/usrp2/dboard_interface.cpp
@@ -0,0 +1,111 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/utils.hpp>
+#include "dboard_interface.hpp"
+#include "fw_common.h"
+
+/***********************************************************************
+ * Structors
+ **********************************************************************/
+dboard_interface::dboard_interface(impl_base *impl){
+    _impl = impl;
+}
+
+dboard_interface::~dboard_interface(void){
+    /* NOP */
+}
+
+/***********************************************************************
+ * Clock Rates
+ **********************************************************************/
+double dboard_interface::get_rx_clock_rate(void){
+    return _impl->get_master_clock_freq();
+}
+
+double dboard_interface::get_tx_clock_rate(void){
+    return _impl->get_master_clock_freq();
+}
+
+/***********************************************************************
+ * GPIO
+ **********************************************************************/
+/*!
+ * Static function to convert a gpio bank enum
+ * to an over-the-wire value for the usrp2 control.
+ * \param bank the dboard interface gpio bank enum
+ * \return an over the wire representation
+ */
+static uint8_t gpio_bank_to_otw(uhd::usrp::dboard::interface::gpio_bank_t bank){
+    switch(bank){
+    case uhd::usrp::dboard::interface::GPIO_TX_BANK: return USRP2_GPIO_BANK_TX;
+    case uhd::usrp::dboard::interface::GPIO_RX_BANK: return USRP2_GPIO_BANK_RX;
+    }
+    throw std::runtime_error("unknown gpio bank");
+}
+
+void dboard_interface::set_gpio_ddr(gpio_bank_t bank, uint16_t value, uint16_t mask){
+    //setup the out data
+    usrp2_ctrl_data_t out_data;
+    out_data.id = htonl(USRP2_CTRL_ID_USE_THESE_GPIO_DDR_SETTINGS_BRO);
+    out_data.data.gpio_config.bank = gpio_bank_to_otw(bank);
+    out_data.data.gpio_config.value = htons(value);
+    out_data.data.gpio_config.mask = htons(mask);
+
+    //send and recv
+    usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data);
+    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_GPIO_DDR_SETTINGS_DUDE);
+}
+
+void dboard_interface::write_gpio(gpio_bank_t bank, uint16_t value, uint16_t mask){
+    //setup the out data
+    usrp2_ctrl_data_t out_data;
+    out_data.id = htonl(USRP2_CTRL_ID_SET_YOUR_GPIO_PIN_OUTS_BRO);
+    out_data.data.gpio_config.bank = gpio_bank_to_otw(bank);
+    out_data.data.gpio_config.value = htons(value);
+    out_data.data.gpio_config.mask = htons(mask);
+
+    //send and recv
+    usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data);
+    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_I_SET_THE_GPIO_PIN_OUTS_DUDE);
+}
+
+uint16_t dboard_interface::read_gpio(gpio_bank_t bank){
+    //setup the out data
+    usrp2_ctrl_data_t out_data;
+    out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_GPIO_PIN_VALS_BRO);
+    out_data.data.gpio_config.bank = gpio_bank_to_otw(bank);
+
+    //send and recv
+    usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data);
+    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_HERE_IS_YOUR_GPIO_PIN_VALS_DUDE);
+    return ntohs(in_data.data.gpio_config.value);
+}
+
+void dboard_interface::set_atr_reg(gpio_bank_t bank, uint16_t tx_value, uint16_t rx_value, uint16_t mask){
+    //setup the out data
+    usrp2_ctrl_data_t out_data;
+    out_data.id = htonl(USRP2_CTRL_ID_USE_THESE_ATR_SETTINGS_BRO);
+    out_data.data.atr_config.bank = gpio_bank_to_otw(bank);
+    out_data.data.atr_config.tx_value = htons(tx_value);
+    out_data.data.atr_config.rx_value = htons(rx_value);
+    out_data.data.atr_config.mask = htons(mask);
+
+    //send and recv
+    usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data);
+    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_ATR_SETTINGS_DUDE);
+}
diff --git a/host/lib/usrp/mboard/usrp2/dboard_interface.hpp b/host/lib/usrp/mboard/usrp2/dboard_interface.hpp
new file mode 100644
index 000000000..645681f43
--- /dev/null
+++ b/host/lib/usrp/mboard/usrp2/dboard_interface.hpp
@@ -0,0 +1,58 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/dboard/interface.hpp>
+#include "impl_base.hpp"
+
+#ifndef INCLUDED_DBOARD_INTERFACE_HPP
+#define INCLUDED_DBOARD_INTERFACE_HPP
+
+class dboard_interface : public uhd::usrp::dboard::interface{
+public:
+    dboard_interface(impl_base *impl);
+
+    ~dboard_interface(void);
+
+    void write_aux_dac(int, int){}
+
+    int read_aux_adc(int){return 0;}
+
+    void set_atr_reg(gpio_bank_t, uint16_t, uint16_t, uint16_t);
+
+    void set_gpio_ddr(gpio_bank_t, uint16_t, uint16_t);
+
+    void write_gpio(gpio_bank_t, uint16_t, uint16_t);
+
+    uint16_t read_gpio(gpio_bank_t);
+
+    void write_i2c (int, const std::string &){}
+
+    std::string read_i2c (int, size_t){return "";}
+
+    void write_spi (spi_dev_t, spi_push_t, const std::string &){}
+
+    std::string read_spi (spi_dev_t, spi_latch_t, size_t){return "";}
+
+    double get_rx_clock_rate(void);
+
+    double get_tx_clock_rate(void);
+
+private:
+    impl_base *_impl;
+};
+
+#endif /* INCLUDED_DBOARD_INTERFACE_HPP */
diff --git a/host/lib/usrp/mboard/usrp2/fw_common.h b/host/lib/usrp/mboard/usrp2/fw_common.h
new file mode 100644
index 000000000..8cd15c7c3
--- /dev/null
+++ b/host/lib/usrp/mboard/usrp2/fw_common.h
@@ -0,0 +1,127 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_USRP2_FW_COMMON_H
+#define INCLUDED_USRP2_FW_COMMON_H
+
+/*!
+ * Structs and constants for usrp2 communication.
+ * This header is shared by the firmware and host code.
+ * Therefore, this header may only contain valid C code.
+ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// udp ports for the usrp2 communication
+// Dynamic and/or private ports: 49152-65535
+#define USRP2_UDP_CTRL_PORT 49152
+#define USRP2_UDP_DATA_PORT 49153
+
+typedef enum{
+    USRP2_CTRL_ID_HUH_WHAT,
+    //USRP2_CTRL_ID_FOR_SURE, //TODO error condition enums
+    //USRP2_CTRL_ID_SUX_MAN,
+
+    USRP2_CTRL_ID_GIVE_ME_YOUR_IP_ADDR_BRO,
+    USRP2_CTRL_ID_THIS_IS_MY_IP_ADDR_DUDE,
+    USRP2_CTRL_ID_HERE_IS_A_NEW_IP_ADDR_BRO,
+
+    USRP2_CTRL_ID_GIVE_ME_YOUR_MAC_ADDR_BRO,
+    USRP2_CTRL_ID_THIS_IS_MY_MAC_ADDR_DUDE,
+    USRP2_CTRL_ID_HERE_IS_A_NEW_MAC_ADDR_BRO,
+
+    USRP2_CTRL_ID_GIVE_ME_YOUR_DBOARD_IDS_BRO,
+    USRP2_CTRL_ID_THESE_ARE_MY_DBOARD_IDS_DUDE,
+
+    USRP2_CTRL_ID_HERES_A_NEW_CLOCK_CONFIG_BRO,
+    USRP2_CTRL_ID_GOT_THE_NEW_CLOCK_CONFIG_DUDE,
+
+    USRP2_CTRL_ID_USE_THESE_GPIO_DDR_SETTINGS_BRO,
+    USRP2_CTRL_ID_GOT_THE_GPIO_DDR_SETTINGS_DUDE,
+
+    USRP2_CTRL_ID_SET_YOUR_GPIO_PIN_OUTS_BRO,
+    USRP2_CTRL_ID_I_SET_THE_GPIO_PIN_OUTS_DUDE,
+
+    USRP2_CTRL_ID_GIVE_ME_YOUR_GPIO_PIN_VALS_BRO,
+    USRP2_CTRL_ID_HERE_IS_YOUR_GPIO_PIN_VALS_DUDE,
+
+    USRP2_CTRL_ID_USE_THESE_ATR_SETTINGS_BRO,
+    USRP2_CTRL_ID_GOT_THE_ATR_SETTINGS_DUDE,
+
+    USRP2_CTRL_ID_PEACE_OUT
+
+} usrp2_ctrl_id_t;
+
+typedef enum{
+    USRP2_PPS_SOURCE_SMA,
+    USRP2_PPS_SOURCE_MIMO
+} usrp2_pps_source_t;
+
+typedef enum{
+    USRP2_PPS_POLARITY_POS,
+    USRP2_PPS_POLARITY_NEG
+} usrp2_pps_polarity_t;
+
+typedef enum{
+    USRP2_REF_SOURCE_INT,
+    USRP2_REF_SOURCE_SMA,
+    USRP2_REF_SOURCE_MIMO
+} usrp2_ref_source_t;
+
+typedef enum{
+    USRP2_GPIO_BANK_RX,
+    USRP2_GPIO_BANK_TX
+} usrp2_gpio_bank_t;
+
+typedef struct{
+    uint32_t id;
+    uint32_t seq;
+    union{
+        uint32_t ip_addr;
+        uint8_t mac_addr[6];
+        struct {
+            uint16_t rx_id;
+            uint16_t tx_id;
+        } dboard_ids;
+        struct {
+            uint8_t pps_source;
+            uint8_t pps_polarity;
+            uint8_t ref_source;
+            uint8_t _pad;
+        } clock_config;
+        struct {
+            uint8_t bank;
+            uint8_t _pad[3];
+            uint16_t value;
+            uint16_t mask;
+        } gpio_config;
+        struct {
+            uint8_t bank;
+            uint8_t _pad[3];
+            uint16_t tx_value;
+            uint16_t rx_value;
+            uint16_t mask;
+        } atr_config;
+    } data;
+} usrp2_ctrl_data_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_USRP2_FW_COMMON_H */
diff --git a/host/lib/usrp/mboard/usrp2/impl_base.cpp b/host/lib/usrp/mboard/usrp2/impl_base.cpp
new file mode 100644
index 000000000..e81b7cdb0
--- /dev/null
+++ b/host/lib/usrp/mboard/usrp2/impl_base.cpp
@@ -0,0 +1,276 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <boost/format.hpp>
+#include <uhd/utils.hpp>
+#include <uhd/props.hpp>
+#include <iostream>
+#include "impl_base.hpp"
+#include "dboard_interface.hpp"
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+/***********************************************************************
+ * Structors
+ **********************************************************************/
+impl_base::impl_base(
+    uhd::transport::udp::sptr ctrl_transport,
+    uhd::transport::udp::sptr data_transport
+){
+    _ctrl_transport = ctrl_transport;
+    _data_transport = data_transport;
+
+    //grab the dboard ids over the control line
+    usrp2_ctrl_data_t out_data;
+    out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_DBOARD_IDS_BRO);
+    usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
+    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_THESE_ARE_MY_DBOARD_IDS_DUDE);
+    std::cout << boost::format("rx id 0x%.2x, tx id 0x%.2x")
+        % ntohs(in_data.data.dboard_ids.rx_id)
+        % ntohs(in_data.data.dboard_ids.tx_id) << std::endl;
+
+    //extract the dboard ids an convert them to enums
+    dboard::dboard_id_t rx_dboard_id = static_cast<dboard::dboard_id_t>(
+        ntohs(in_data.data.dboard_ids.rx_id)
+    );
+    dboard::dboard_id_t tx_dboard_id = static_cast<dboard::dboard_id_t>(
+        ntohs(in_data.data.dboard_ids.tx_id)
+    );
+
+    //create a new dboard interface and manager
+    dboard::interface::sptr _dboard_interface(
+        new dboard_interface(this)
+    );
+    dboard::manager::sptr dboard_manager(
+        new dboard::manager(rx_dboard_id, tx_dboard_id, _dboard_interface)
+    );
+
+    //load dboards
+    _rx_dboards[""] = dboard_impl::sptr(new dboard_impl(dboard_manager, dboard_impl::TYPE_RX));
+    _tx_dboards[""] = dboard_impl::sptr(new dboard_impl(dboard_manager, dboard_impl::TYPE_TX));
+
+    //TOD load dsps
+
+    //init the pps source clock config
+    _pps_source_dict["sma"]  = USRP2_PPS_SOURCE_SMA;
+    _pps_source_dict["mimo"] = USRP2_PPS_SOURCE_MIMO;
+    _pps_source = "sma";
+
+    //init the pps polarity clock config
+    _pps_polarity_dict["pos"] = USRP2_PPS_POLARITY_POS;
+    _pps_polarity_dict["neg"] = USRP2_PPS_POLARITY_NEG;
+    _pps_polarity = "neg";
+
+    //init the ref source clock config
+    _ref_source_dict["int"]  = USRP2_REF_SOURCE_INT;
+    _ref_source_dict["sma"]  = USRP2_REF_SOURCE_SMA;
+    _ref_source_dict["mimo"] = USRP2_REF_SOURCE_MIMO;
+    _ref_source = "int";
+
+    //update the clock config (sends a control packet)
+    update_clock_config();
+}
+
+impl_base::~impl_base(void){
+    /* NOP */
+}
+
+/***********************************************************************
+ * Misc Access Methods
+ **********************************************************************/
+double impl_base::get_master_clock_freq(void){
+    return 100e6;
+}
+
+void impl_base::update_clock_config(void){
+    //setup the out data
+    usrp2_ctrl_data_t out_data;
+    out_data.id = htonl(USRP2_CTRL_ID_HERES_A_NEW_CLOCK_CONFIG_BRO);
+    out_data.data.clock_config.pps_source   = _pps_source_dict  [_pps_source];
+    out_data.data.clock_config.pps_polarity = _pps_polarity_dict[_pps_polarity];
+    out_data.data.clock_config.ref_source   = _ref_source_dict  [_ref_source];
+
+    //send and recv
+    usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
+    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_GOT_THE_NEW_CLOCK_CONFIG_DUDE);
+}
+
+/***********************************************************************
+ * Control Send/Recv
+ **********************************************************************/
+usrp2_ctrl_data_t impl_base::ctrl_send_and_recv(const usrp2_ctrl_data_t &out_data){
+    boost::mutex::scoped_lock lock(_ctrl_mutex);
+
+    //fill in the seq number and send
+    usrp2_ctrl_data_t out_copy = out_data;
+    out_copy.seq = htonl(++_ctrl_seq_num);
+    _ctrl_transport->send(boost::asio::buffer(&out_copy, sizeof(usrp2_ctrl_data_t)));
+
+    //loop and recieve until the time is up
+    size_t num_timeouts = 0;
+    while(true){
+        uhd::shared_iovec iov = _ctrl_transport->recv();
+        if (iov.len < sizeof(usrp2_ctrl_data_t)){
+            //sleep a little so we dont burn cpu
+            if (num_timeouts++ > 50) break;
+            boost::this_thread::sleep(boost::posix_time::milliseconds(1));
+        }else{
+            //handle the received data
+            usrp2_ctrl_data_t in_data = *reinterpret_cast<const usrp2_ctrl_data_t *>(iov.base);
+            if (ntohl(in_data.seq) == _ctrl_seq_num){
+                return in_data;
+            }
+            //didnt get seq, continue on...
+        }
+    }
+    throw std::runtime_error("usrp2 no control response");
+}
+
+/***********************************************************************
+ * Get Properties
+ **********************************************************************/
+void impl_base::get(const wax::obj &key_, wax::obj &val){
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+
+    //handle the get request conditioned on the key
+    switch(wax::cast<mboard_prop_t>(key)){
+    case MBOARD_PROP_NAME:
+        val = std::string("usrp2 mboard");
+        return;
+
+    case MBOARD_PROP_OTHERS:
+        val = prop_names_t(); //empty other props
+        return;
+
+    case MBOARD_PROP_RX_DBOARD:
+        val = _rx_dboards[name]->get_link();
+        return;
+
+    case MBOARD_PROP_RX_DBOARD_NAMES:
+        val = prop_names_t(_rx_dboards.get_keys());
+        return;
+
+    case MBOARD_PROP_TX_DBOARD:
+        val = _tx_dboards[name]->get_link();
+        return;
+
+    case MBOARD_PROP_TX_DBOARD_NAMES:
+        val = prop_names_t(_tx_dboards.get_keys());
+        return;
+
+    case MBOARD_PROP_MTU:
+        // FIXME we dont know the real MTU...
+        // give them something to fragment about
+        val = size_t(1500);
+        return;
+
+    case MBOARD_PROP_CLOCK_RATE:
+        val = freq_t(get_master_clock_freq());
+        return;
+
+    case MBOARD_PROP_RX_DSP:
+        throw std::runtime_error("unhandled prop in usrp2 mboard");
+
+    case MBOARD_PROP_RX_DSP_NAMES:
+        throw std::runtime_error("unhandled prop in usrp2 mboard");
+
+    case MBOARD_PROP_TX_DSP:
+        throw std::runtime_error("unhandled prop in usrp2 mboard");
+
+    case MBOARD_PROP_TX_DSP_NAMES:
+        throw std::runtime_error("unhandled prop in usrp2 mboard");
+
+    case MBOARD_PROP_PPS_SOURCE:
+        val = _pps_source;
+        return;
+
+    case MBOARD_PROP_PPS_SOURCE_NAMES:
+        val = prop_names_t(_pps_source_dict.get_keys());
+        return;
+
+    case MBOARD_PROP_PPS_POLARITY:
+        val = _pps_polarity;
+        return;
+
+    case MBOARD_PROP_REF_SOURCE:
+        val = _ref_source;
+        return;
+
+    case MBOARD_PROP_REF_SOURCE_NAMES:
+        val = prop_names_t(_ref_source_dict.get_keys());
+        return;
+
+    case MBOARD_PROP_TIME_NOW:
+    case MBOARD_PROP_TIME_NEXT_PPS:
+        throw std::runtime_error("Error: trying to get write-only property on usrp2 mboard");
+
+    }
+}
+
+/***********************************************************************
+ * Set Properties
+ **********************************************************************/
+void impl_base::set(const wax::obj &key, const wax::obj &val){
+    //handle the get request conditioned on the key
+    switch(wax::cast<mboard_prop_t>(key)){
+
+    case MBOARD_PROP_PPS_SOURCE:{
+            std::string name = wax::cast<std::string>(val);
+            ASSERT_THROW(_pps_source_dict.has_key(name));
+            _pps_source = name; //shadow
+            update_clock_config();
+        }
+        return;
+
+    case MBOARD_PROP_PPS_POLARITY:{
+            std::string name = wax::cast<std::string>(val);
+            ASSERT_THROW(_pps_polarity_dict.has_key(name));
+            _pps_polarity = name; //shadow
+            update_clock_config();
+        }
+        return;
+
+    case MBOARD_PROP_REF_SOURCE:{
+            std::string name = wax::cast<std::string>(val);
+            ASSERT_THROW(_ref_source_dict.has_key(name));
+            _ref_source = name; //shadow
+            update_clock_config();
+        }
+        return;
+
+    case MBOARD_PROP_NAME:
+    case MBOARD_PROP_OTHERS:
+    case MBOARD_PROP_MTU:
+    case MBOARD_PROP_CLOCK_RATE:
+    case MBOARD_PROP_RX_DSP:
+    case MBOARD_PROP_RX_DSP_NAMES:
+    case MBOARD_PROP_TX_DSP:
+    case MBOARD_PROP_TX_DSP_NAMES:
+    case MBOARD_PROP_RX_DBOARD:
+    case MBOARD_PROP_RX_DBOARD_NAMES:
+    case MBOARD_PROP_TX_DBOARD:
+    case MBOARD_PROP_TX_DBOARD_NAMES:
+    case MBOARD_PROP_PPS_SOURCE_NAMES:
+    case MBOARD_PROP_REF_SOURCE_NAMES:
+    case MBOARD_PROP_TIME_NOW:
+    case MBOARD_PROP_TIME_NEXT_PPS:
+        throw std::runtime_error("Error: trying to set read-only property on usrp2 mboard");
+
+    }
+}
diff --git a/host/lib/usrp/mboard/usrp2/impl_base.hpp b/host/lib/usrp/mboard/usrp2/impl_base.hpp
new file mode 100644
index 000000000..b808cf2b1
--- /dev/null
+++ b/host/lib/usrp/mboard/usrp2/impl_base.hpp
@@ -0,0 +1,78 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <boost/utility.hpp>
+#include <boost/thread.hpp>
+#include <boost/shared_ptr.hpp>
+#include <uhd/transport/udp.hpp>
+#include <uhd/dict.hpp>
+#include "dboard_impl.hpp"
+#include "fw_common.h"
+
+#ifndef INCLUDED_IMPL_BASE_HPP
+#define INCLUDED_IMPL_BASE_HPP
+
+class impl_base : boost::noncopyable, public wax::obj{
+public:
+    typedef boost::shared_ptr<impl_base> sptr;
+
+    /*!
+     * Create a new usrp2 impl base.
+     * \param ctrl_transport the udp transport for control
+     * \param data_transport the udp transport for data
+     */
+    impl_base(
+        uhd::transport::udp::sptr ctrl_transport,
+        uhd::transport::udp::sptr data_transport
+    );
+
+    ~impl_base(void);
+
+    //performs a control transaction
+    usrp2_ctrl_data_t ctrl_send_and_recv(const usrp2_ctrl_data_t &);
+
+    //properties access methods
+    void get(const wax::obj &, wax::obj &);
+    void set(const wax::obj &, const wax::obj &);
+
+    //misc access methods
+    double get_master_clock_freq(void);
+    void update_clock_config(void);
+
+private:
+    //udp transports for control and data
+    uhd::transport::udp::sptr _ctrl_transport;
+    uhd::transport::udp::sptr _data_transport;
+
+    //private vars for dealing with send/recv control
+    uint32_t _ctrl_seq_num;
+    boost::mutex _ctrl_mutex;
+
+    //containers for the dboard objects
+    uhd::dict<std::string, dboard_impl::sptr> _rx_dboards;
+    uhd::dict<std::string, dboard_impl::sptr> _tx_dboards;
+
+    //shadows for various settings
+    std::string _pps_source, _pps_polarity, _ref_source;
+
+    //mappings from clock config strings to over the wire enums
+    uhd::dict<std::string, usrp2_pps_source_t>   _pps_source_dict;
+    uhd::dict<std::string, usrp2_pps_polarity_t> _pps_polarity_dict;
+    uhd::dict<std::string, usrp2_ref_source_t>   _ref_source_dict;
+};
+
+#endif /* INCLUDED_IMPL_BASE_HPP */
diff --git a/host/lib/usrp/usrp.cpp b/host/lib/usrp/usrp.cpp
new file mode 100644
index 000000000..86a40ebd8
--- /dev/null
+++ b/host/lib/usrp/usrp.cpp
@@ -0,0 +1,98 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/usrp.hpp>
+#include <uhd/usrp/mboard/usrp2.hpp>
+#include <uhd/usrp/mboard/test.hpp>
+#include <boost/format.hpp>
+#include <boost/bind.hpp>
+#include <stdexcept>
+
+using namespace uhd::usrp;
+
+/***********************************************************************
+ * default callbacks for the send and recv
+ * these should be replaced with callbacks from the mboard object
+ **********************************************************************/
+static void send_raw_default(const std::vector<boost::asio::const_buffer> &){
+    throw std::runtime_error("No callback registered for send raw");
+}
+
+static uhd::shared_iovec recv_raw_default(void){
+    throw std::runtime_error("No callback registered for recv raw");
+}
+
+/***********************************************************************
+ * the usrp device wrapper
+ **********************************************************************/
+usrp::usrp(const device_addr_t &device_addr){
+    //set the default callbacks, the code below should replace them
+    _send_raw_cb = boost::bind(&send_raw_default, _1);
+    _recv_raw_cb = boost::bind(&recv_raw_default);
+
+    //create mboard based on the device addr
+    if (not device_addr.has_key("type")){
+        //TODO nothing
+    }
+    else if (device_addr["type"] == "test"){
+        _mboards[""] = mboard::base::sptr(new mboard::test(device_addr));
+    }
+    else if (device_addr["type"] == "udp"){
+        _mboards[""] = mboard::base::sptr(new mboard::usrp2(device_addr));
+    }
+}
+
+usrp::~usrp(void){
+    /* NOP */
+}
+
+void usrp::get(const wax::obj &key_, wax::obj &val){
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+
+    //handle the get request conditioned on the key
+    switch(wax::cast<device_prop_t>(key)){
+    case DEVICE_PROP_NAME:
+        val = std::string("usrp device");
+        return;
+
+    case DEVICE_PROP_MBOARD:
+        if (not _mboards.has_key(name)) throw std::invalid_argument(
+            str(boost::format("Unknown mboard name %s") % name)
+        );
+        //turn the mboard sptr object into a wax::obj::sptr
+        //this allows the properties access through the wax::proxy
+        val = _mboards[name]->get_link();
+        return;
+
+    case DEVICE_PROP_MBOARD_NAMES:
+        val = prop_names_t(_mboards.get_keys());
+        return;
+    }
+}
+
+void usrp::set(const wax::obj &, const wax::obj &){
+    throw std::runtime_error("Cannot set in usrp device");
+}
+
+void usrp::send_raw(const std::vector<boost::asio::const_buffer> &buffs){
+    return _send_raw_cb(buffs);
+}
+
+uhd::shared_iovec usrp::recv_raw(void){
+    return _recv_raw_cb();
+}