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

66 files changed, 4764 insertions, 0 deletions

diff --git a/host/.gitignore b/host/.gitignore
new file mode 100644
index 000000000..796b96d1c
--- /dev/null
+++ b/host/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/host/AUTHORS b/host/AUTHORS
new file mode 100644
index 000000000..d0fe52768
--- /dev/null
+++ b/host/AUTHORS
@@ -0,0 +1 @@
+Josh Blum - josh@ettus.com
diff --git a/host/CMakeLists.txt b/host/CMakeLists.txt
new file mode 100644
index 000000000..70c04631b
--- /dev/null
+++ b/host/CMakeLists.txt
@@ -0,0 +1,108 @@
+#
+# 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/>.
+#
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(UHD)
+ENABLE_TESTING()
+
+########################################################################
+# Setup CPack
+########################################################################
+SET(CPACK_PACKAGE_VERSION_MAJOR 0)
+SET(CPACK_PACKAGE_VERSION_MINOR 0)
+SET(CPACK_PACKAGE_VERSION_PATCH 0)
+SET(CPACK_RESOURCE_FILE_README ${CMAKE_SOURCE_DIR}/README)
+SET(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/LICENSE)
+INCLUDE(CPack) #include after setting vars
+
+########################################################################
+# Install Dirs
+########################################################################
+SET(RUNTIME_DIR bin)
+SET(LIBRARY_DIR lib)
+SET(RESOURCE_DIR share)
+SET(HEADER_DIR include)
+
+########################################################################
+# Local Include Dir
+########################################################################
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include)
+
+########################################################################
+# Optional Compiler Flags
+########################################################################
+INCLUDE(CheckCXXCompilerFlag)
+FUNCTION(UHD_ADD_OPTIONAL_CXX_COMPILER_FLAG flag have)
+    CHECK_CXX_COMPILER_FLAG(${flag} ${have})
+    IF(${have})
+        ADD_DEFINITIONS(${flag})
+    ENDIF(${have})
+ENDFUNCTION(UHD_ADD_OPTIONAL_CXX_COMPILER_FLAG)
+
+UHD_ADD_OPTIONAL_CXX_COMPILER_FLAG(-Wall      HAVE_WALL)
+UHD_ADD_OPTIONAL_CXX_COMPILER_FLAG(-Wextra    HAVE_WEXTRA)
+UHD_ADD_OPTIONAL_CXX_COMPILER_FLAG(-pedantic  HAVE_PEDANTIC)
+UHD_ADD_OPTIONAL_CXX_COMPILER_FLAG(-ansi      HAVE_ANSI)
+
+########################################################################
+# Setup Boost
+########################################################################
+FIND_PACKAGE(Boost 1.36 REQUIRED
+    date_time
+    program_options
+    system
+    thread
+    unit_test_framework
+)
+
+INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIRS})
+LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
+
+########################################################################
+# Create Uninstall Target
+########################################################################
+CONFIGURE_FILE(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+    @ONLY
+)
+
+ADD_CUSTOM_TARGET(uninstall
+  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+)
+
+########################################################################
+# Create Pkg Config File
+########################################################################
+CONFIGURE_FILE(
+    "${CMAKE_SOURCE_DIR}/uhd.pc.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/uhd.pc"
+    @ONLY
+)
+
+INSTALL(
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/uhd.pc
+    DESTINATION ${LIBRARY_DIR}/pkgconfig
+)
+
+########################################################################
+# Add the subdirectories
+########################################################################
+ADD_SUBDIRECTORY(apps)
+ADD_SUBDIRECTORY(include)
+ADD_SUBDIRECTORY(lib)
+ADD_SUBDIRECTORY(test)
diff --git a/host/LICENSE b/host/LICENSE
new file mode 100644
index 000000000..9aa03b39b
--- /dev/null
+++ b/host/LICENSE
@@ -0,0 +1,12 @@
+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/>.
diff --git a/host/README b/host/README
new file mode 100644
index 000000000..f19275c41
--- /dev/null
+++ b/host/README
@@ -0,0 +1,26 @@
+########################################################################
+# Ettus Research - Universal Hardware Driver
+########################################################################
+The hardware driver for Ettus Research products.
+
+########################################################################
+# Supported USRP Motherboards
+########################################################################
+USRP2 - gigabit ethernet
+
+########################################################################
+# Supported USRP Daughterboards
+########################################################################
+Basic RX
+Basic TX
+
+########################################################################
+# CMake Instructions
+########################################################################
+cd <uhd_src_dir>
+mkdir build
+cd build
+cmake ../
+make
+make test
+sudo make install
diff --git a/host/apps/CMakeLists.txt b/host/apps/CMakeLists.txt
new file mode 100644
index 000000000..f4428f958
--- /dev/null
+++ b/host/apps/CMakeLists.txt
@@ -0,0 +1,22 @@
+#
+# 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/>.
+#
+
+ADD_EXECUTABLE(discover_usrps discover_usrps.cpp)
+
+TARGET_LINK_LIBRARIES(discover_usrps uhd)
+
+INSTALL(TARGETS discover_usrps RUNTIME DESTINATION ${RUNTIME_DIR})
diff --git a/host/apps/discover_usrps.cpp b/host/apps/discover_usrps.cpp
new file mode 100644
index 000000000..92c90f89a
--- /dev/null
+++ b/host/apps/discover_usrps.cpp
@@ -0,0 +1,65 @@
+//
+// 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.hpp>
+#include <boost/program_options.hpp>
+#include <boost/format.hpp>
+#include <iostream>
+
+namespace po = boost::program_options;
+using namespace uhd;
+
+int main(int argc, char *argv[]){
+    po::options_description desc("Allowed options");
+    desc.add_options()
+        ("help", "help message")
+        ("ip-addr", po::value<std::string>(), "usrp2 ip address")
+    ;
+
+    po::variables_map vm;
+    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::notify(vm); 
+
+    //print the help message
+    if (vm.count("help")) {
+        std::cout << boost::format("Discover USRPs %s") % desc << std::endl;
+        return ~0;
+    }
+
+    //extract the ip address (not optional for now)
+    uhd::device_addr_t device_addr;
+    device_addr["type"] = "udp";
+    if (vm.count("ip-addr")) {
+        device_addr["addr"] = vm["ip-addr"].as<std::string>();
+    } else {
+        std::cout << "IP Addess was not set" << std::endl;
+        return ~0;
+    }
+
+    //discover the usrps
+    std::vector<uhd::device_addr_t> device_addrs = uhd::device::discover(device_addr);
+    for (size_t i = 0; i < device_addrs.size(); i++){
+        std::cout << "--------------------------------------------------" << std::endl;
+        std::cout << "-- USRP Device " << i << std::endl;
+        std::cout << "--------------------------------------------------" << std::endl;
+        std::cout << device_addrs[i] << std::endl << std::endl;
+        //make each device just to test (TODO: remove this)
+        device::make(device_addrs[i]);
+    }
+
+    return 0;
+}
diff --git a/host/cmake_uninstall.cmake.in b/host/cmake_uninstall.cmake.in
new file mode 100644
index 000000000..6031a6ca9
--- /dev/null
+++ b/host/cmake_uninstall.cmake.in
@@ -0,0 +1,23 @@
+# http://www.vtk.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F
+
+IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+  MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
+ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+
+FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+STRING(REGEX REPLACE "\n" ";" files "${files}")
+FOREACH(file ${files})
+  MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
+  IF(EXISTS "$ENV{DESTDIR}${file}")
+    EXEC_PROGRAM(
+      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+      OUTPUT_VARIABLE rm_out
+      RETURN_VALUE rm_retval
+      )
+    IF(NOT "${rm_retval}" STREQUAL 0)
+      MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
+    ENDIF(NOT "${rm_retval}" STREQUAL 0)
+  ELSE(EXISTS "$ENV{DESTDIR}${file}")
+    MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
+  ENDIF(EXISTS "$ENV{DESTDIR}${file}")
+ENDFOREACH(file)
diff --git a/host/include/CMakeLists.txt b/host/include/CMakeLists.txt
new file mode 100644
index 000000000..34b705cab
--- /dev/null
+++ b/host/include/CMakeLists.txt
@@ -0,0 +1,24 @@
+#
+# 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/>.
+#
+
+
+ADD_SUBDIRECTORY(uhd)
+
+INSTALL(FILES
+    uhd.hpp
+    DESTINATION ${HEADER_DIR}
+)
diff --git a/host/include/uhd.hpp b/host/include/uhd.hpp
new file mode 100644
index 000000000..ee8c13dfe
--- /dev/null
+++ b/host/include/uhd.hpp
@@ -0,0 +1,24 @@
+//
+// 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_UHD_HPP
+#define INCLUDED_UHD_HPP
+
+//include convenience headers
+#include <uhd/device.hpp>
+
+#endif /* INCLUDED_UHD_HPP */
diff --git a/host/include/uhd/CMakeLists.txt b/host/include/uhd/CMakeLists.txt
new file mode 100644
index 000000000..006c54f22
--- /dev/null
+++ b/host/include/uhd/CMakeLists.txt
@@ -0,0 +1,33 @@
+#
+# 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/>.
+#
+
+
+ADD_SUBDIRECTORY(transport)
+ADD_SUBDIRECTORY(usrp)
+
+INSTALL(FILES
+    device.hpp
+    device_addr.hpp
+    dict.hpp
+    gain_handler.hpp
+    props.hpp
+    shared_iovec.hpp
+    time_spec.hpp
+    utils.hpp
+    wax.hpp
+    DESTINATION ${HEADER_DIR}/uhd
+)
diff --git a/host/include/uhd/device.hpp b/host/include/uhd/device.hpp
new file mode 100644
index 000000000..dfbfbd7c0
--- /dev/null
+++ b/host/include/uhd/device.hpp
@@ -0,0 +1,82 @@
+//
+// 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_UHD_DEVICE_HPP
+#define INCLUDED_UHD_DEVICE_HPP
+
+#include <uhd/device_addr.hpp>
+#include <uhd/props.hpp>
+#include <uhd/wax.hpp>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <boost/asio/buffer.hpp>
+#include <uhd/shared_iovec.hpp>
+#include <vector>
+
+namespace uhd{
+
+/*!
+ * The usrp device interface represents the usrp hardware.
+ * The api allows for discovery, configuration, and streaming.
+ */
+class device : boost::noncopyable, public wax::obj{
+
+public:
+    typedef boost::shared_ptr<device> sptr;
+
+    //structors
+    device(void);
+    virtual ~device(void);
+
+    /*!
+     * \brief Discover usrp devices attached to the host.
+     *
+     * The hint device address should be used to narrow down the search
+     * to particular transport types and/or transport arguments.
+     *
+     * \param hint a partially (or fully) filled in device address
+     * \return a vector of device addresses for all usrps on the system
+     */
+    static device_addrs_t discover(const device_addr_t &hint);
+
+    /*!
+     * \brief Create a new usrp device from the device address hint.
+     *
+     * The make routine will call discover and pick one of the results.
+     * By default, the first result will be used to create a new device.
+     * Use the which parameter as an index into the list of results.
+     *
+     * \param hint a partially (or fully) filled in device address
+     * \param which which address to use when multiple are discovered
+     * \return a shared pointer to a new device instance
+     */
+    static sptr make(const device_addr_t &hint, size_t which = 0);
+
+    /*!
+     * Get the device address for this board.
+     */
+    device_addr_t get_device_addr(void);
+
+    //the io interface
+    virtual void send_raw(const std::vector<boost::asio::const_buffer> &) = 0;
+    virtual uhd::shared_iovec recv_raw(void) = 0;
+};
+
+} //namespace uhd
+
+#endif /* INCLUDED_UHD_DEVICE_HPP */
diff --git a/host/include/uhd/device_addr.hpp b/host/include/uhd/device_addr.hpp
new file mode 100644
index 000000000..8ea580321
--- /dev/null
+++ b/host/include/uhd/device_addr.hpp
@@ -0,0 +1,67 @@
+//
+// 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_UHD_DEVICE_ADDR_HPP
+#define INCLUDED_UHD_DEVICE_ADDR_HPP
+
+#include <uhd/dict.hpp>
+#include <string>
+#include <iostream>
+#include <netinet/ether.h>
+#include <stdint.h>
+#include <vector>
+
+namespace uhd{
+
+    /*!
+    * Wrapper for an ethernet mac address.
+    * Provides conversion between string and binary formats.
+    */
+    struct mac_addr_t{
+        struct ether_addr mac_addr;
+        mac_addr_t(const std::string &mac_addr_str = "00:00:00:00:00:00");
+        std::string to_string(void) const;
+    };
+
+    /*!
+     * The device address args are just a mapping of key/value string pairs.
+     * When left empty, the discovery routine will try to find all usrps.
+     * The discovery can be narrowed down by specifying the transport type arguments.
+     *
+     * For example, to access a specific usrp2 one would specify the transport type
+     * ("type", "udp") and the transport args ("addr", "<resolvable_hostname_or_addr>").
+     */
+    typedef dict<std::string, std::string> device_addr_t;
+    typedef std::vector<device_addr_t> device_addrs_t;
+
+    /*!
+     * Function to turn a device address into a string.
+     * Just having the operator<< below should be sufficient.
+     * However, boost format seems to complain with the %
+     * and this is just easier because it works.
+     * \param device_addr a device address instance
+     * \return the string representation
+     */
+    std::string device_addr_to_string(const device_addr_t &device_addr);
+
+} //namespace uhd
+
+//ability to use types with stream operators
+std::ostream& operator<<(std::ostream &, const uhd::device_addr_t &);
+std::ostream& operator<<(std::ostream &, const uhd::mac_addr_t &);
+
+#endif /* INCLUDED_UHD_DEVICE_ADDR_HPP */
diff --git a/host/include/uhd/dict.hpp b/host/include/uhd/dict.hpp
new file mode 100644
index 000000000..1ed28551a
--- /dev/null
+++ b/host/include/uhd/dict.hpp
@@ -0,0 +1,140 @@
+//
+// 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_UHD_DICT_HPP
+#define INCLUDED_UHD_DICT_HPP
+
+#include <map>
+#include <vector>
+#include <stdexcept>
+#include <boost/foreach.hpp>
+
+namespace uhd{
+
+    /*!
+     * A templated dictionary class with a python-like interface.
+     * Its wraps around a std::map internally.
+     */
+    template <class Key, class Val> class dict{
+    public:
+        typedef std::map<Key, Val> map_t;
+        typedef std::pair<Key, Val> pair_t;
+
+        /*!
+         * Create a new empty dictionary.
+         */
+        dict(void){
+            /* NOP */
+        }
+
+        /*!
+         * Create a dictionary from a map.
+         * \param map a map with key value pairs
+         */
+        dict(const map_t &map){
+            _map = map;
+        }
+
+        /*!
+         * Destroy this dict.
+         */
+        ~dict(void){
+            /* NOP */
+        }
+
+        /*!
+         * Get a list of the keys in this dict.
+         * \return vector of keys
+         */
+        std::vector<Key> get_keys(void) const{
+            std::vector<Key> keys;
+            BOOST_FOREACH(pair_t p, _map){
+                keys.push_back(p.first);
+            }
+            return keys;
+        }
+
+        /*!
+         * Get a list of the values in this dict.
+         * \return vector of values
+         */
+        std::vector<Val> get_vals(void) const{
+            std::vector<Val> vals;
+            BOOST_FOREACH(pair_t p, _map){
+                vals.push_back(p.second);
+            }
+            return vals;
+        }
+
+        /*!
+         * Does the dictionary contain this key?
+         * \param key the key to look for
+         * \return true if found
+         */
+        bool has_key(const Key &key) const{
+            BOOST_FOREACH(pair_t p, _map){
+                if (p.first == key) return true;
+            }
+            return false;
+        }
+
+        /*!
+         * Get a value for the given key if it exists.
+         * If the key is not found throw an error.
+         * \param key the key to look for
+         * \return the value at the key
+         * \throw an exception when not found
+         */
+        const Val &operator[](const Key &key) const{
+            if (has_key(key)){
+                return _map.find(key)->second;
+            }
+            throw std::invalid_argument("key not found in dict");
+        }
+
+        /*!
+         * Set a value for the given key, however, in reality
+         * it really returns a reference which can be assigned to.
+         * \param key the key to set to
+         * \return a reference to the value
+         */
+        Val &operator[](const Key &key){
+            return _map[key];
+        }
+
+        /*!
+         * Pop an item out of the dictionary.
+         * \param key the item key
+         * \return the value of the item
+         * \throw an exception when not found
+         */
+        Val pop_key(const Key &key){
+            if (has_key(key)){
+                Val val = _map.find(key)->second;
+                _map.erase(key);
+                return val;
+            }
+            throw std::invalid_argument("key not found in dict");
+        }
+
+    private:
+        map_t _map; //private container
+    };
+
+} //namespace uhd
+
+#endif /* INCLUDED_UHD_DICT_HPP */
diff --git a/host/include/uhd/gain_handler.hpp b/host/include/uhd/gain_handler.hpp
new file mode 100644
index 000000000..06800315a
--- /dev/null
+++ b/host/include/uhd/gain_handler.hpp
@@ -0,0 +1,101 @@
+//
+// 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/shared_ptr.hpp>
+#include <uhd/wax.hpp>
+#include <uhd/props.hpp>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+
+#ifndef INCLUDED_UHD_GAIN_HANDLER_HPP
+#define INCLUDED_UHD_GAIN_HANDLER_HPP
+
+namespace uhd{
+
+class gain_handler{
+public:
+    typedef boost::shared_ptr<gain_handler> sptr;
+
+    template <class T> gain_handler(
+        wax::obj *wax_obj_ptr, const T &gain_prop,
+        const T &gain_min_prop, const T &gain_max_prop,
+        const T &gain_step_prop, const T &gain_names_prop
+    ){
+        _wax_obj_ptr = wax_obj_ptr;
+        _gain_prop = gain_prop;
+        _gain_min_prop = gain_min_prop;
+        _gain_max_prop = gain_max_prop;
+        _gain_step_prop = gain_step_prop;
+        _gain_names_prop = gain_names_prop;
+        _is_equal = boost::bind(&gain_handler::is_equal<T>, _1, _2);
+    }
+
+    ~gain_handler(void);
+
+    /*!
+     * Intercept gets for overall gain, min, max, step.
+     * Ensures that the gain name is valid.
+     * \return true for handled, false to pass on
+     */
+    bool intercept_get(const wax::obj &key, wax::obj &val);
+
+    /*!
+     * Intercept sets for overall gain.
+     * Ensures that the gain name is valid.
+     * Ensures that the new gain is within range.
+     * \return true for handled, false to pass on
+     */
+    bool intercept_set(const wax::obj &key, const wax::obj &val);
+
+private:
+
+    wax::obj     *_wax_obj_ptr;
+    wax::obj      _gain_prop;
+    wax::obj      _gain_min_prop;
+    wax::obj      _gain_max_prop;
+    wax::obj      _gain_step_prop;
+    wax::obj      _gain_names_prop;
+
+    /*!
+     * Verify that the key is valid:
+     * If its a named prop for gain, ensure that name is valid.
+     * If the name if not valid, throw a std::invalid_argument.
+     * The name can only be valid if its in the list of gain names.
+     */
+    void _check_key(const wax::obj &key);
+
+    /*
+     * Private interface to test if two wax types are equal:
+     * The constructor will bind an instance of this for a specific type.
+     * This bound equals functions allows the intercept methods to be non-templated.
+     */
+    template <class T> static bool is_equal(const wax::obj &a, const wax::obj &b){
+        try{
+            return wax::cast<T>(a) == wax::cast<T>(b);
+        }
+        catch(const wax::bad_cast &){
+            return false;
+        }
+    }
+    boost::function<bool(const wax::obj &, const wax::obj &)> _is_equal;
+
+};
+
+} //namespace uhd
+
+#endif /* INCLUDED_UHD_GAIN_HANDLER_HPP */
+
diff --git a/host/include/uhd/props.hpp b/host/include/uhd/props.hpp
new file mode 100644
index 000000000..4012ffbd2
--- /dev/null
+++ b/host/include/uhd/props.hpp
@@ -0,0 +1,165 @@
+//
+// 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/tuple/tuple.hpp>
+#include <uhd/time_spec.hpp>
+#include <uhd/wax.hpp>
+#include <complex>
+#include <vector>
+
+#ifndef INCLUDED_UHD_PROPS_HPP
+#define INCLUDED_UHD_PROPS_HPP
+
+namespace uhd{
+
+    //common typedefs for board properties
+    typedef float gain_t;
+    typedef double freq_t;
+
+    //scalar types
+    typedef int int_scalar_t;
+    typedef float real_scalar_t;
+    typedef std::complex<real_scalar_t> complex_scalar_t;
+
+    //vector types
+    typedef std::vector<int_scalar_t> int_vec_t;
+    typedef std::vector<real_scalar_t> real_vec_t;
+    typedef std::vector<complex_scalar_t> complex_vec_t;
+
+    //typedef for handling named properties
+    typedef std::vector<std::string> prop_names_t;
+    typedef boost::tuple<wax::obj, std::string> named_prop_t;
+
+    /*!
+     * Utility function to separate a named property into its components.
+     * \param key a reference to the prop object
+     * \param name a reference to the name object
+     */
+    inline named_prop_t extract_named_prop(const wax::obj &key, const std::string &name = ""){
+        if (key.type() == typeid(named_prop_t)){
+            return wax::cast<named_prop_t>(key);
+        }
+        return named_prop_t(key, name);
+    }
+
+    /*!
+    * Possible device properties:
+    *   In general, a device will have a single mboard.
+    *   In certain mimo applications, multiple boards
+    *   will be present in the interface for configuration.
+    */
+    enum device_prop_t{
+        DEVICE_PROP_NAME,              //ro, std::string
+        DEVICE_PROP_MBOARD,            //ro, wax::obj
+        DEVICE_PROP_MBOARD_NAMES       //ro, prop_names_t
+    };
+
+    /*!
+    * Possible device mboard properties:
+    *   The general mboard properties are listed below.
+    *   Custom properties can be identified with a string
+    *   and discovered though the others property.
+    */
+    enum mboard_prop_t{
+        MBOARD_PROP_NAME,              //ro, std::string
+        MBOARD_PROP_OTHERS,            //ro, prop_names_t
+        MBOARD_PROP_MTU,               //ro, size_t
+        MBOARD_PROP_CLOCK_RATE,        //ro, freq_t
+        MBOARD_PROP_RX_DSP,            //ro, wax::obj
+        MBOARD_PROP_RX_DSP_NAMES,      //ro, prop_names_t
+        MBOARD_PROP_TX_DSP,            //ro, wax::obj
+        MBOARD_PROP_TX_DSP_NAMES,      //ro, prop_names_t
+        MBOARD_PROP_RX_DBOARD,         //ro, wax::obj
+        MBOARD_PROP_RX_DBOARD_NAMES,   //ro, prop_names_t
+        MBOARD_PROP_TX_DBOARD,         //ro, wax::obj
+        MBOARD_PROP_TX_DBOARD_NAMES,   //ro, prop_names_t
+        MBOARD_PROP_PPS_SOURCE,        //rw, std::string (sma, mimo)
+        MBOARD_PROP_PPS_SOURCE_NAMES,  //ro, prop_names_t
+        MBOARD_PROP_PPS_POLARITY,      //rw, std::string (pos, neg)
+        MBOARD_PROP_REF_SOURCE,        //rw, std::string (int, sma, mimo)
+        MBOARD_PROP_REF_SOURCE_NAMES,  //ro, prop_names_t
+        MBOARD_PROP_TIME_NOW,          //wo, time_spec_t
+        MBOARD_PROP_TIME_NEXT_PPS      //wo, time_spec_t
+    };
+
+    /*!
+    * Possible device dsp properties:
+    *   A dsp can have a wide range of possible properties.
+    *   A ddc would have a properties "decim", "freq", "taps"...
+    *   Other properties could be gains, complex scalars, enables...
+    *   For this reason the only required properties of a dsp is a name
+    *   and a property to get list of other possible properties.
+    */
+    enum dsp_prop_t{
+        DSP_PROP_NAME,                 //ro, std::string
+        DSP_PROP_OTHERS                //ro, prop_names_t
+    };
+
+    /*!
+    * Possible device dboard properties
+    */
+    enum dboard_prop_t{
+        DBOARD_PROP_NAME,              //ro, std::string
+        DBOARD_PROP_SUBDEV,            //ro, wax::obj
+        DBOARD_PROP_SUBDEV_NAMES,      //ro, prop_names_t
+        DBOARD_PROP_CODEC              //ro, wax::obj
+    };
+
+    /*!
+    * Possible device codec properties:
+    *   A codec is expected to have a rate and gain elements.
+    *   Other properties can be discovered through the others prop.
+    */
+    enum codec_prop_t{
+        CODEC_PROP_NAME,               //ro, std::string
+        CODEC_PROP_OTHERS,             //ro, prop_names_t
+        CODEC_PROP_GAIN,               //rw, gain_t
+        CODEC_PROP_GAIN_MAX,           //ro, gain_t
+        CODEC_PROP_GAIN_MIN,           //ro, gain_t
+        CODEC_PROP_GAIN_STEP,          //ro, gain_t
+        CODEC_PROP_GAIN_NAMES,         //ro, prop_names_t
+        CODEC_PROP_CLOCK_RATE          //ro, freq_t
+    };
+
+    /*!
+    * Possible device subdev properties
+    */
+    enum subdev_prop_t{
+        SUBDEV_PROP_NAME,              //ro, std::string
+        SUBDEV_PROP_OTHERS,            //ro, prop_names_t
+        SUBDEV_PROP_GAIN,              //rw, gain_t
+        SUBDEV_PROP_GAIN_MAX,          //ro, gain_t
+        SUBDEV_PROP_GAIN_MIN,          //ro, gain_t
+        SUBDEV_PROP_GAIN_STEP,         //ro, gain_t
+        SUBDEV_PROP_GAIN_NAMES,        //ro, prop_names_t
+        SUBDEV_PROP_FREQ,              //rw, freq_t
+        SUBDEV_PROP_FREQ_MAX,          //ro, freq_t
+        SUBDEV_PROP_FREQ_MIN,          //ro, freq_t
+        SUBDEV_PROP_ANTENNA,           //rw, std::string
+        SUBDEV_PROP_ANTENNA_NAMES,     //ro, prop_names_t
+        SUBDEV_PROP_ENABLED,           //rw, bool
+        SUBDEV_PROP_QUADRATURE,        //ro, bool
+        SUBDEV_PROP_IQ_SWAPPED,        //ro, bool
+        SUBDEV_PROP_SPECTRUM_INVERTED, //ro, bool
+        SUBDEV_PROP_IS_TX,             //ro, bool
+        SUBDEV_PROP_RSSI,              //ro, gain_t
+        SUBDEV_PROP_BANDWIDTH          //rw, freq_t
+    };
+
+} //namespace uhd
+
+#endif /* INCLUDED_UHD_PROPS_HPP */
diff --git a/host/include/uhd/shared_iovec.hpp b/host/include/uhd/shared_iovec.hpp
new file mode 100644
index 000000000..a120e55d5
--- /dev/null
+++ b/host/include/uhd/shared_iovec.hpp
@@ -0,0 +1,54 @@
+//
+// 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_UHD_SHARED_IOVEC_HPP
+#define INCLUDED_UHD_SHARED_IOVEC_HPP
+
+#include <boost/shared_array.hpp>
+#include <stdint.h>
+
+namespace uhd{
+
+/*!
+ * A shared iovec contains a shared array and its length.
+ * Creating a new shared iovec allocates new memory.
+ * This memory is freed when all copies are destroyed.
+ */
+class shared_iovec{
+public:
+    /*!
+     * Create a shared iovec and allocate memory.
+     * \param len the length in bytes
+     */
+    shared_iovec(size_t len=0);
+
+    /*!
+     * Destroy a shared iovec.
+     * Will not free the memory unless this is the last copy.
+     */
+    ~shared_iovec(void);
+
+    void *base;
+    size_t len;
+
+private:
+    boost::shared_array<uint8_t> _shared_array;
+};
+
+} //namespace uhd
+
+#endif /* INCLUDED_UHD_SHARED_IOVEC_HPP */
diff --git a/host/include/uhd/time_spec.hpp b/host/include/uhd/time_spec.hpp
new file mode 100644
index 000000000..e5657e555
--- /dev/null
+++ b/host/include/uhd/time_spec.hpp
@@ -0,0 +1,57 @@
+//
+// 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 <stdint.h>
+
+#ifndef INCLUDED_UHD_TIME_SPEC_HPP
+#define INCLUDED_UHD_TIME_SPEC_HPP
+
+namespace uhd{
+
+    /*!
+     * A time_spec_t holds a seconds and ticks time value.
+     * The temporal width of a tick depends on the device's clock rate.
+     * The time_spec_t can be used when setting the time on devices
+     * and for controlling the start of streaming for applicable dsps.
+     */
+    struct time_spec_t{
+        uint32_t secs;
+        uint32_t ticks;
+
+        /*!
+         * Create a time_spec_t that holds a wildcard time.
+         * This will have implementation-specific meaning.
+         */
+        time_spec_t(void){
+            secs = ~0;
+            ticks = ~0;
+        }
+
+        /*!
+         * Create a time_spec_t from seconds and ticks.
+         * \param new_secs the new seconds
+         * \param new_ticks the new ticks (default = 0)
+         */
+        time_spec_t(uint32_t new_secs, uint32_t new_ticks = 0){
+            secs = new_secs;
+            ticks = new_ticks;
+        }
+    };
+
+} //namespace uhd
+
+#endif /* INCLUDED_UHD_TIME_SPEC_HPP */
diff --git a/host/include/uhd/transport/CMakeLists.txt b/host/include/uhd/transport/CMakeLists.txt
new file mode 100644
index 000000000..b786eb945
--- /dev/null
+++ b/host/include/uhd/transport/CMakeLists.txt
@@ -0,0 +1,22 @@
+#
+# 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/>.
+#
+
+
+INSTALL(FILES
+    udp.hpp
+    DESTINATION ${HEADER_DIR}/uhd/transport
+)
diff --git a/host/include/uhd/transport/udp.hpp b/host/include/uhd/transport/udp.hpp
new file mode 100644
index 000000000..6db6bd377
--- /dev/null
+++ b/host/include/uhd/transport/udp.hpp
@@ -0,0 +1,75 @@
+//
+// 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/asio.hpp>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+#include <uhd/shared_iovec.hpp>
+
+#ifndef INCLUDED_UHD_TRANSPORT_UDP_HPP
+#define INCLUDED_UHD_TRANSPORT_UDP_HPP
+
+namespace uhd{ namespace transport{
+
+class udp : boost::noncopyable{
+public:
+    typedef boost::shared_ptr<udp> sptr;
+
+    /*!
+     * Constructor.
+     * The address will be resolved, it can be a host name or ipv4.
+     * The port will be resolved, it can be a port type or number.
+     * \param addr a string representing the destination address
+     * \param port a string representing the destination port
+     * \param bcast if true, enable the broadcast option on the socket
+     */
+    udp(const std::string &addr, const std::string &port, bool bcast = false);
+
+    /*!
+     * Destructor
+     */
+    ~udp(void);
+
+    /*!
+     * Send a vector of buffer (like send_msg).
+     * \param buffs a vector of asio buffers
+     */
+    void send(const std::vector<boost::asio::const_buffer> &buffs);
+
+    /*!
+     * Send a single buffer.
+     * \param buff single asio buffer
+     */
+    void send(const boost::asio::const_buffer &buff);
+
+    /*!
+     * Receive a buffer. The memory is managed internally.
+     * Calling recv will invalidate the buffer of the previous recv.
+     * \return a shared iovec with allocated memory
+     */
+    uhd::shared_iovec recv(void);
+
+private:
+    boost::asio::ip::udp::socket   *_socket;
+    boost::asio::ip::udp::endpoint _receiver_endpoint;
+    boost::asio::ip::udp::endpoint _sender_endpoint;
+    boost::asio::io_service        _io_service;
+};
+
+}} //namespace
+
+#endif /* INCLUDED_UHD_TRANSPORT_UDP_HPP */
diff --git a/host/include/uhd/usrp/CMakeLists.txt b/host/include/uhd/usrp/CMakeLists.txt
new file mode 100644
index 000000000..d3040c3cc
--- /dev/null
+++ b/host/include/uhd/usrp/CMakeLists.txt
@@ -0,0 +1,25 @@
+#
+# 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/>.
+#
+
+
+ADD_SUBDIRECTORY(dboard)
+ADD_SUBDIRECTORY(mboard)
+
+INSTALL(FILES
+    usrp.hpp
+    DESTINATION ${HEADER_DIR}/uhd/usrp
+)
diff --git a/host/include/uhd/usrp/dboard/CMakeLists.txt b/host/include/uhd/usrp/dboard/CMakeLists.txt
new file mode 100644
index 000000000..e1ecc3b70
--- /dev/null
+++ b/host/include/uhd/usrp/dboard/CMakeLists.txt
@@ -0,0 +1,25 @@
+#
+# 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/>.
+#
+
+
+INSTALL(FILES
+    base.hpp
+    id.hpp
+    interface.hpp
+    manager.hpp
+    DESTINATION ${HEADER_DIR}/uhd/usrp/dboard
+)
diff --git a/host/include/uhd/usrp/dboard/base.hpp b/host/include/uhd/usrp/dboard/base.hpp
new file mode 100644
index 000000000..845e2f669
--- /dev/null
+++ b/host/include/uhd/usrp/dboard/base.hpp
@@ -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/>.
+//
+
+#ifndef INCLUDED_UHD_USRP_DBOARD_BASE_HPP
+#define INCLUDED_UHD_USRP_DBOARD_BASE_HPP
+
+#include <uhd/wax.hpp>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <uhd/usrp/dboard/interface.hpp>
+
+namespace uhd{ namespace usrp{ namespace dboard{
+
+/*!
+ * A daughter board base class for all dboards.
+ * Only other dboard base classes should inherit this.
+ */
+class base : boost::noncopyable{
+public:
+    typedef boost::shared_ptr<base> sptr;
+    //the constructor args consist of a subdev name and an interface
+    //derived classes should pass the args into the base class ctor
+    //but should not have to deal with the internals of the args
+    typedef boost::tuple<std::string, interface::sptr> ctor_args_t;
+
+    //structors
+    base(ctor_args_t const&);
+    virtual ~base(void);
+
+    //interface
+    virtual void rx_get(const wax::obj &key, wax::obj &val) = 0;
+    virtual void rx_set(const wax::obj &key, const wax::obj &val) = 0;
+    virtual void tx_get(const wax::obj &key, wax::obj &val) = 0;
+    virtual void tx_set(const wax::obj &key, const wax::obj &val) = 0;
+
+protected:
+    std::string get_subdev_name(void);
+    interface::sptr get_interface(void);
+
+private:
+    std::string        _subdev_name;
+    interface::sptr    _dboard_interface;
+};
+
+/*!
+ * A xcvr daughter board implements rx and tx methods
+ * Sub classes for xcvr boards should inherit this.
+ */
+class xcvr_base : public base{
+public:
+    /*!
+     * Create a new xcvr dboard object, override in subclasses.
+     */
+    xcvr_base(ctor_args_t const&);
+    virtual ~xcvr_base(void);
+};
+
+/*!
+ * A rx daughter board only implements rx methods.
+ * Sub classes for rx-only boards should inherit this.
+ */
+class rx_base : public base{
+public:
+    /*!
+     * Create a new rx dboard object, override in subclasses.
+     */
+    rx_base(ctor_args_t const&);
+
+    virtual ~rx_base(void);
+
+    //override here so the derived classes cannot
+    void tx_get(const wax::obj &key, wax::obj &val);
+    void tx_set(const wax::obj &key, const wax::obj &val);
+};
+
+/*!
+ * A tx daughter board only implements tx methods.
+ * Sub classes for rx-only boards should inherit this.
+ */
+class tx_base : public base{
+public:
+    /*!
+     * Create a new rx dboard object, override in subclasses.
+     */
+    tx_base(ctor_args_t const&);
+
+    virtual ~tx_base(void);
+
+    //override here so the derived classes cannot
+    void rx_get(const wax::obj &key, wax::obj &val);
+    void rx_set(const wax::obj &key, const wax::obj &val);
+};
+
+}}} //namespace
+
+#endif /* INCLUDED_UHD_USRP_DBOARD_BASE_HPP */
diff --git a/host/include/uhd/usrp/dboard/id.hpp b/host/include/uhd/usrp/dboard/id.hpp
new file mode 100644
index 000000000..98c0acc3a
--- /dev/null
+++ b/host/include/uhd/usrp/dboard/id.hpp
@@ -0,0 +1,35 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <iostream>
+
+#ifndef INCLUDED_UHD_USRP_DBOARD_ID_HPP
+#define INCLUDED_UHD_USRP_DBOARD_ID_HPP
+
+namespace uhd{ namespace usrp{ namespace dboard{
+
+enum dboard_id_t{
+    ID_NONE     = 0xffff,
+    ID_BASIC_TX = 0x0000,
+    ID_BASIC_RX = 0x0001
+};
+
+}}} //namespace
+
+std::ostream& operator<<(std::ostream &, const uhd::usrp::dboard::dboard_id_t &);
+
+#endif /* INCLUDED_UHD_USRP_DBOARD_ID_HPP */
diff --git a/host/include/uhd/usrp/dboard/interface.hpp b/host/include/uhd/usrp/dboard/interface.hpp
new file mode 100644
index 000000000..68669b99d
--- /dev/null
+++ b/host/include/uhd/usrp/dboard/interface.hpp
@@ -0,0 +1,167 @@
+//
+// 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_UHD_USRP_DBOARD_INTERFACE_HPP
+#define INCLUDED_UHD_USRP_DBOARD_INTERFACE_HPP
+
+#include <boost/shared_ptr.hpp>
+#include <stdint.h>
+
+namespace uhd{ namespace usrp{ namespace dboard{
+
+/*!
+ * The daughter board interface to be subclassed.
+ * A dboard instance interfaces with the mboard though this api. 
+ * This interface provides i2c, spi, gpio, atr, aux dac/adc access.
+ * Each mboard should have a specially tailored dboard interface.
+ */
+class interface{
+public:
+    typedef boost::shared_ptr<interface> sptr;
+
+    //tells the host which device to use
+    enum spi_dev_t{
+        SPI_TX_DEV,
+        SPI_RX_DEV
+    };
+
+    //args for writing spi data
+    enum spi_push_t{
+        SPI_PUSH_RISE,
+        SPI_PUSH_FALL
+    };
+
+    //args for reading spi data
+    enum spi_latch_t{
+        SPI_LATCH_RISE,
+        SPI_LATCH_FALL
+    };
+
+    //tell the host which gpio bank
+    enum gpio_bank_t{
+        GPIO_TX_BANK,
+        GPIO_RX_BANK
+    };
+
+    //structors
+    interface(void);
+    virtual ~interface(void);
+
+    /*!
+     * Write to an aux dac.
+     * \param which_dac the dac index 0, 1, 2, 3...
+     * \param value the value to write
+     */
+    virtual void write_aux_dac(int which_dac, int value) = 0;
+
+    /*!
+     * Read from an aux adc.
+     * \param which_adc the adc index 0, 1, 2, 3...
+     * \return the value that was read
+     */
+    virtual int read_aux_adc(int which_adc) = 0;
+
+    /*!
+     * Set daughterboard ATR register.
+     * The ATR register for a particular bank has 2 values:
+     * one value when transmitting, one when receiving.
+     * The mask controls which pins are controlled by ATR.
+     *
+     * \param bank      GPIO_TX_BANK or GPIO_RX_BANK
+     * \param tx_value  16-bits, 0=FPGA output low, 1=FPGA output high
+     * \param rx_value  16-bits, 0=FPGA output low, 1=FPGA output high
+     * \param mask      16-bits, 0=software, 1=atr
+     */
+    virtual void set_atr_reg(gpio_bank_t bank, uint16_t tx_value, uint16_t rx_value, uint16_t mask) = 0;
+
+    /*!
+     * Set daughterboard GPIO data direction register.
+     *
+     * \param bank      GPIO_TX_BANK or GPIO_RX_BANK
+     * \param value     16-bits, 0=FPGA input, 1=FPGA output
+     * \param mask      16-bits, 0=ignore, 1=set
+     */
+    virtual void set_gpio_ddr(gpio_bank_t bank, uint16_t value, uint16_t mask) = 0;
+
+    /*!
+     * Set daughterboard GPIO pin values.
+     *
+     * \param bank     GPIO_TX_BANK or GPIO_RX_BANK
+     * \param value    16 bits, 0=low, 1=high
+     * \param mask     16 bits, 0=ignore, 1=set
+     */
+    virtual void write_gpio(gpio_bank_t bank, uint16_t value, uint16_t mask) = 0;
+
+    /*!
+     * Read daughterboard GPIO pin values
+     *
+     * \param bank GPIO_TX_BANK or GPIO_RX_BANK
+     * \return the value of the gpio bank
+     */
+    virtual uint16_t read_gpio(gpio_bank_t bank) = 0;
+
+    /*!
+     * \brief Write to I2C peripheral
+     * \param i2c_addr I2C bus address (7-bits)
+     * \param buf the data to write
+     */
+    virtual void write_i2c(int i2c_addr, const std::string &buf) = 0;
+
+    /*!
+     * \brief Read from I2C peripheral
+     * \param i2c_addr I2C bus address (7-bits)
+     * \param len number of bytes to read
+     * \return the data read if successful, else a zero length string.
+     */
+    virtual std::string read_i2c(int i2c_addr, size_t len) = 0;
+
+    /*!
+     * \brief Write data to SPI bus peripheral.
+     *
+     * \param dev which spi device
+     * \param push args for writing
+     * \param buf the data to write
+     */
+    virtual void write_spi(spi_dev_t dev, spi_push_t push, const std::string &buf) = 0;
+
+    /*!
+     * \brief Read data from SPI bus peripheral.
+     *
+     * \param dev which spi device
+     * \param push args for reading
+     * \param len number of bytes to read
+     * \return the data read if sucessful, else a zero length string.
+     */
+    virtual std::string read_spi(spi_dev_t dev, spi_latch_t latch, size_t len) = 0;
+
+    /*!
+     * \brief Get the rate of the rx dboard clock.
+     * \return the clock rate
+     */
+    virtual double get_rx_clock_rate(void) = 0;
+
+    /*!
+     * \brief Get the rate of the tx dboard clock.
+     * \return the clock rate
+     */
+    virtual double get_tx_clock_rate(void) = 0;
+
+};
+
+}}} //namespace
+
+#endif /* INCLUDED_UHD_USRP_DBOARD_INTERFACE_HPP */
diff --git a/host/include/uhd/usrp/dboard/manager.hpp b/host/include/uhd/usrp/dboard/manager.hpp
new file mode 100644
index 000000000..e53ba8e52
--- /dev/null
+++ b/host/include/uhd/usrp/dboard/manager.hpp
@@ -0,0 +1,82 @@
+//
+// 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_UHD_USRP_DBOARD_MANAGER_HPP
+#define INCLUDED_UHD_USRP_DBOARD_MANAGER_HPP
+
+#include <uhd/dict.hpp>
+#include <uhd/wax.hpp>
+#include <uhd/props.hpp>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+#include <uhd/usrp/dboard/base.hpp>
+#include <uhd/usrp/dboard/id.hpp>
+
+namespace uhd{ namespace usrp{ namespace dboard{
+
+/*!
+ * A daughter board subdev manager class.
+ * Create subdev instances for each subdev on a dboard.
+ * Provide wax::obj access to the subdevs inside.
+ */
+class manager : boost::noncopyable{
+
+public:
+
+    //dboard constructor (each dboard should have a ::make with this signature)
+    typedef base::sptr(*dboard_ctor_t)(base::ctor_args_t const&);
+
+    /*!
+     * Register subdevices for a given dboard id.
+     *
+     * \param dboard_id the dboard id (rx or tx)
+     * \param dboard_ctor the dboard constructor function pointer
+     * \param subdev_names the names of the subdevs on this dboard
+     */
+    static void register_subdevs(
+        dboard_id_t dboard_id,
+        dboard_ctor_t dboard_ctor,
+        const prop_names_t &subdev_names
+    );
+
+public:
+    typedef boost::shared_ptr<manager> sptr;
+    //structors
+    manager(
+        dboard_id_t rx_dboard_id,
+        dboard_id_t tx_dboard_id,
+        interface::sptr dboard_interface
+    );
+    ~manager(void);
+
+    //interface
+    prop_names_t get_rx_subdev_names(void);
+    prop_names_t get_tx_subdev_names(void);
+    wax::obj get_rx_subdev(const std::string &subdev_name);
+    wax::obj get_tx_subdev(const std::string &subdev_name);
+
+private:
+    //list of rx and tx dboards in this manager
+    //each dboard here is actually a subdevice proxy
+    //the subdevice proxy is internal to the cpp file
+    uhd::dict<std::string, wax::obj> _rx_dboards;
+    uhd::dict<std::string, wax::obj> _tx_dboards;
+};
+
+}}} //namespace
+
+#endif /* INCLUDED_UHD_USRP_DBOARD_MANAGER_HPP */
diff --git a/host/include/uhd/usrp/mboard/CMakeLists.txt b/host/include/uhd/usrp/mboard/CMakeLists.txt
new file mode 100644
index 000000000..79aab8677
--- /dev/null
+++ b/host/include/uhd/usrp/mboard/CMakeLists.txt
@@ -0,0 +1,24 @@
+#
+# 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/>.
+#
+
+
+INSTALL(FILES
+    base.hpp
+    test.hpp
+    usrp2.hpp
+    DESTINATION ${HEADER_DIR}/uhd/usrp/mboard
+)
diff --git a/host/include/uhd/usrp/mboard/base.hpp b/host/include/uhd/usrp/mboard/base.hpp
new file mode 100644
index 000000000..a8de81a7e
--- /dev/null
+++ b/host/include/uhd/usrp/mboard/base.hpp
@@ -0,0 +1,45 @@
+//
+// 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_UHD_USRP_MBOARD_BASE_HPP
+#define INCLUDED_UHD_USRP_MBOARD_BASE_HPP
+
+#include <uhd/wax.hpp>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+
+namespace uhd{ namespace usrp{ namespace mboard{
+
+/*!
+ * A base class for usrp mboard objects.
+ */
+class base : boost::noncopyable, public wax::obj{
+public:
+    typedef boost::shared_ptr<base> sptr;
+    base(void);
+    ~base(void);
+
+    //TODO other api calls
+
+private:
+    virtual void get(const wax::obj &, wax::obj &) = 0;
+    virtual void set(const wax::obj &, const wax::obj &) = 0;
+};
+
+}}} //namespace
+
+#endif /* INCLUDED_UHD_USRP_MBOARD_BASE_HPP */
diff --git a/host/include/uhd/usrp/mboard/test.hpp b/host/include/uhd/usrp/mboard/test.hpp
new file mode 100644
index 000000000..04d0ff4c4
--- /dev/null
+++ b/host/include/uhd/usrp/mboard/test.hpp
@@ -0,0 +1,46 @@
+//
+// 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_UHD_USRP_MBOARD_TEST_HPP
+#define INCLUDED_UHD_USRP_MBOARD_TEST_HPP
+
+#include <uhd/usrp/mboard/base.hpp>
+#include <uhd/device_addr.hpp>
+#include <uhd/usrp/dboard/manager.hpp>
+#include <uhd/dict.hpp>
+
+namespace uhd{ namespace usrp{ namespace mboard{
+
+/*!
+ * A test usrp mboard object.
+ * Exercises access routines for the test suite.
+ */
+class test : public base{
+public:
+    test(const device_addr_t &);
+    ~test(void);
+
+private:
+    void get(const wax::obj &, wax::obj &);
+    void set(const wax::obj &, const wax::obj &);
+
+    uhd::dict<std::string, dboard::manager::sptr> _dboard_managers;
+};
+
+}}} //namespace
+
+#endif /* INCLUDED_UHD_USRP_MBOARD_TEST_HPP */
diff --git a/host/include/uhd/usrp/mboard/usrp2.hpp b/host/include/uhd/usrp/mboard/usrp2.hpp
new file mode 100644
index 000000000..5da9f874d
--- /dev/null
+++ b/host/include/uhd/usrp/mboard/usrp2.hpp
@@ -0,0 +1,51 @@
+//
+// 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_UHD_USRP_MBOARD_USRP2_HPP
+#define INCLUDED_UHD_USRP_MBOARD_USRP2_HPP
+
+#include <uhd/usrp/mboard/base.hpp>
+#include <uhd/device_addr.hpp>
+
+namespace uhd{ namespace usrp{ namespace mboard{
+
+/*!
+ * The usrp2 mboard class.
+ */
+class usrp2 : public base{
+public:
+    /*!
+     * Discover usrp2 devices over the ethernet.
+     * This static method will be called by the device::discover.
+     * \param hint a device addr with the usrp2 address filled in
+     * \return a vector of device addresses for all usrp2s found
+     */
+    static device_addrs_t discover(const device_addr_t &hint);
+
+    usrp2(const device_addr_t &);
+    ~usrp2(void);
+
+private:
+    void get(const wax::obj &, wax::obj &);
+    void set(const wax::obj &, const wax::obj &);
+
+    wax::obj _impl;
+};
+
+}}} //namespace
+
+#endif /* INCLUDED_UHD_USRP_MBOARD_USRP2_HPP */
diff --git a/host/include/uhd/usrp/usrp.hpp b/host/include/uhd/usrp/usrp.hpp
new file mode 100644
index 000000000..98c357b77
--- /dev/null
+++ b/host/include/uhd/usrp/usrp.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/>.
+//
+
+#include <uhd/device.hpp>
+#include <uhd/usrp/mboard/base.hpp>
+#include <uhd/dict.hpp>
+
+#ifndef INCLUDED_UHD_USRP_USRP_HPP
+#define INCLUDED_UHD_USRP_USRP_HPP
+
+namespace uhd{ namespace usrp{
+
+/*!
+ * A usrp device provides a device-level interface to usrp mboards.
+ * In most cases, a usrp device will have only one mboard.
+ * In the usrp2 mimo case, this device will have two mboards,
+ * where one talks through the other's control port.
+ */
+class usrp : public device{
+public:
+    usrp(const device_addr_t &device_addr);
+    ~usrp(void);
+
+    //the io interface
+    void send_raw(const std::vector<boost::asio::const_buffer> &);
+    uhd::shared_iovec recv_raw(void);
+
+private:
+    void get(const wax::obj &, wax::obj &);
+    void set(const wax::obj &, const wax::obj &);
+
+    uhd::dict<std::string, mboard::base::sptr> _mboards;
+    boost::function<void(const std::vector<boost::asio::const_buffer> &)> _send_raw_cb;
+    boost::function<uhd::shared_iovec(void)> _recv_raw_cb;
+};
+
+}} //namespace
+
+#endif /* INCLUDED_UHD_USRP_USRP_HPP */
diff --git a/host/include/uhd/utils.hpp b/host/include/uhd/utils.hpp
new file mode 100644
index 000000000..4331aba7e
--- /dev/null
+++ b/host/include/uhd/utils.hpp
@@ -0,0 +1,121 @@
+//
+// 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/wax.hpp>
+#include <boost/foreach.hpp>
+#include <boost/format.hpp>
+#include <boost/function.hpp>
+#include <stdexcept>
+#include <algorithm>
+#include <vector>
+#include <map>
+
+#ifndef INCLUDED_UHD_UTILS_HPP
+#define INCLUDED_UHD_UTILS_HPP
+
+/*!
+ * Useful templated functions and classes that I like to pretend are part of stl
+ */
+namespace std{
+
+    class assert_error : public std::logic_error{
+    public:
+        explicit assert_error(const string& what_arg) : logic_error(what_arg){
+            /* NOP */
+        }
+    };
+
+    #define ASSERT_THROW(_x) if (not (_x)) { \
+        throw std::assert_error("Assertion Failed: " + std::string(#_x)); \
+    }
+
+    template<class T, class InputIterator, class Function>
+    T reduce(InputIterator first, InputIterator last, Function fcn, T init = 0){
+        T tmp = init;
+        for ( ; first != last; ++first ){
+            tmp = fcn(tmp, *first);
+        }
+        return tmp;
+    }
+
+    template<class T, class InputIterator>
+    bool has(InputIterator first, InputIterator last, const T &elem){
+        return last != std::find(first, last, elem);
+    }
+
+    template<class T>
+    T sum(const T &a, const T &b){
+        return a + b;
+    }
+
+    template<typename T> T signum(T n){
+        if (n < 0) return -1;
+        if (n > 0) return 1;
+        return 0;
+    }
+
+}//namespace std
+
+/*namespace uhd{
+
+inline void tune(
+    freq_t target_freq,
+    freq_t lo_offset,
+    wax::obj subdev_freq_proxy,
+    bool subdev_quadrature,
+    bool subdev_spectrum_inverted,
+    bool subdev_is_tx,
+    wax::obj dsp_freq_proxy,
+    freq_t dsp_sample_rate
+){
+    // Ask the d'board to tune as closely as it can to target_freq+lo_offset
+    subdev_freq_proxy = target_freq + lo_offset;
+    freq_t inter_freq = wax::cast<freq_t>(subdev_freq_proxy);
+
+    // Calculate the DDC setting that will downconvert the baseband from the
+    // daughterboard to our target frequency.
+    freq_t delta_freq = target_freq - inter_freq;
+    freq_t delta_sign = std::signum(delta_freq);
+    delta_freq *= delta_sign;
+    delta_freq = fmod(delta_freq, dsp_sample_rate);
+    bool inverted = delta_freq > dsp_sample_rate/2.0;
+    freq_t dxc_freq = inverted? (delta_freq - dsp_sample_rate) : (-delta_freq);
+    dxc_freq *= delta_sign;
+
+    // If the spectrum is inverted, and the daughterboard doesn't do
+    // quadrature downconversion, we can fix the inversion by flipping the
+    // sign of the dxc_freq...  (This only happens using the basic_rx board)
+    if (subdev_spectrum_inverted){
+        inverted = not inverted;
+    }
+    if (inverted and not subdev_quadrature){
+        dxc_freq = -dxc_freq;
+        inverted = not inverted;
+    }
+    if (subdev_is_tx){
+        dxc_freq = -dxc_freq;	// down conversion versus up conversion
+    }
+
+    dsp_freq_proxy = dxc_freq;
+    //freq_t actual_dxc_freq = wax::cast<freq_t>(dsp_freq_proxy);
+
+    //return some kind of tune result tuple/struct
+}
+
+} //namespace uhd*/
+
+#endif /* INCLUDED_UHD_UTILS_HPP */
diff --git a/host/include/uhd/wax.hpp b/host/include/uhd/wax.hpp
new file mode 100644
index 000000000..1d5054351
--- /dev/null
+++ b/host/include/uhd/wax.hpp
@@ -0,0 +1,167 @@
+//
+// 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_WAX_HPP
+#define INCLUDED_WAX_HPP
+
+#include <boost/any.hpp>
+#include <iostream>
+
+/*!
+ * WAX - it's a metaphor!
+ *
+ * The WAX framework allows object to have generic/anyobj properties.
+ * These properties can be addressed through generic/anyobj identifiers.
+ * A property of a WAX object may even be another WAX object.
+ *
+ * When a property is a WAX object, the returned value must be an obj pointer.
+ * A WAX object provides two objs of pointers: obj::ptr and obj::sptr.
+ * The choice of pointer vs smart pointer depends on the owner of the memory.
+ *
+ * Proprties may be referenced though the [] overloaded operator.
+ * The [] operator returns a special proxy that allows for assigment.
+ * Also, the [] operators may be chained as in the folowing examples:
+ *   my_obj[prop1][prop2][prop3] = value
+ *   value = my_obj[prop1][prop2][prop3]
+ *
+ * Any value returned from an access operation is of wax::obj.
+ * To use this value, it must be cast with wax::cast<new_obj>(value).
+ */
+
+namespace wax{
+
+    /*!
+     * WAX object base class:
+     *
+     * A wax obj has two major purposes:
+     *   1) to act as a polymorphic container, just like boost any
+     *   2) to provide a nested set/get properties interface
+     *
+     * Internally, the polymorphic container is handled by a boost any.
+     * For properties, a subclass should override the set and get methods.
+     * For property nesting, wax obj subclasses return special links
+     * to other wax obj subclasses, and the api handles the magic.
+     */
+    class obj{
+    public:
+
+        /*!
+         * Default constructor:
+         * The contents will be empty.
+         */
+        obj(void);
+
+        /*!
+         * Copy constructor:
+         * The contents will be cloned.
+         * \param o another wax::obj
+         */
+        obj(const obj &o);
+
+        /*!
+         * Templated any type constructor:
+         * The contents can be anything.
+         * Uses the boost::any to handle the magic.
+         * \param o an object of any type
+         */
+        template<class T> obj(const T &o){
+            _contents = o;
+        }
+
+        /*!
+         * Destructor.
+         */
+        virtual ~obj(void);
+
+        /*!
+         * The chaining operator:
+         * This operator allows access objs with properties.
+         * A call to the [] operator will return a new proxy obj.
+         * The proxy object is an obj with special proxy contents.
+         * Assignment and casting can be used on this special object
+         * to access the property referenced by the obj key.
+         * \param key a key to identify a property within this obj
+         * \return a special wax obj that proxies the obj and key
+         */
+        obj operator[](const obj &key);
+
+        /*!
+         * The assignment operator:
+         * This operator allows for assignment of new contents.
+         * In the special case where this obj contains a proxy,
+         * the value will be set to the proxy's property reference.
+         * \param val the new value to assign to the wax obj
+         * \return a reference to this obj (*this)
+         */
+        obj & operator=(const obj &val);
+
+        /*!
+         * Get a link in the chain:
+         * When a wax obj returns another wax obj as part of a get call,
+         * the return value should be set to the result of this method.
+         * Doing so will ensure chain-ability of the returned object.
+         * \return an obj containing a valid link to a wax obj
+         */
+        obj get_link(void) const;
+
+        /*!
+         * Get the type of the contents of this obj.
+         * \return a reference to the type_info
+         */
+        const std::type_info & type(void) const;
+
+    private:
+        //private interface (override in subclasses)
+        virtual void get(const obj &, obj &);
+        virtual void set(const obj &, const obj &);
+
+        /*!
+         * Resolve the contents of this obj.
+         * In the case where this obj is a proxy,
+         * the referenced property will be resolved.
+         * Otherwise, just get the private contents.
+         * \return a boost any type with contents
+         */
+        boost::any resolve(void) const;
+        template<class T> friend T cast(const obj &);
+
+        //private contents of this obj
+        boost::any _contents;
+
+    };
+
+    /*!
+     * The wax::bad cast will be thrown when
+     * cast is called with the wrong typeid.
+     */
+    typedef boost::bad_any_cast bad_cast;
+
+    /*!
+     * Cast a wax::obj into the desired obj.
+     * Usage wax::cast<new_obj>(my_value).
+     *
+     * \param val the obj to cast
+     * \return an object of the desired type
+     * \throw wax::bad_cast when the cast fails
+     */
+    template<class T> T cast(const obj &val){
+        return boost::any_cast<T>(val.resolve());
+    }
+
+} //namespace wax
+
+#endif /* INCLUDED_WAX_HPP */
diff --git a/host/lib/CMakeLists.txt b/host/lib/CMakeLists.txt
new file mode 100644
index 000000000..295943a6f
--- /dev/null
+++ b/host/lib/CMakeLists.txt
@@ -0,0 +1,43 @@
+#
+# 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/>.
+#
+
+
+ADD_LIBRARY(uhd SHARED
+    device.cpp
+    device_addr.cpp
+    gain_handler.cpp
+    shared_iovec.cpp
+    uhd.cpp
+    wax.cpp
+    transport/udp.cpp
+    usrp/usrp.cpp
+    usrp/dboard/basic.cpp
+    usrp/dboard/base.cpp
+    usrp/dboard/id.cpp
+    usrp/dboard/interface.cpp
+    usrp/dboard/manager.cpp
+    usrp/mboard/base.cpp
+    usrp/mboard/test.cpp
+    usrp/mboard/usrp2.cpp
+    usrp/mboard/usrp2/impl_base.cpp
+    usrp/mboard/usrp2/dboard_impl.cpp
+    usrp/mboard/usrp2/dboard_interface.cpp
+)
+
+TARGET_LINK_LIBRARIES(uhd ${Boost_LIBRARIES})
+
+INSTALL(TARGETS uhd LIBRARY DESTINATION ${LIBRARY_DIR})
diff --git a/host/lib/device.cpp b/host/lib/device.cpp
new file mode 100644
index 000000000..822733217
--- /dev/null
+++ b/host/lib/device.cpp
@@ -0,0 +1,74 @@
+//
+// 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/device.hpp>
+#include <boost/format.hpp>
+#include <stdexcept>
+
+using namespace uhd;
+
+device_addrs_t device::discover(const device_addr_t &hint){
+    device_addrs_t device_addrs;
+    if (not hint.has_key("type")){
+        //TODO nothing
+    }
+    else if (hint["type"] == "test"){
+        //make a copy of the hint for testing
+        device_addr_t test_device_addr = hint;
+        device_addrs.push_back(test_device_addr);
+    }
+    else if (hint["type"] == "udp"){
+        std::vector<device_addr_t> usrp2_addrs = usrp::mboard::usrp2::discover(hint);
+        device_addrs.insert(device_addrs.begin(), usrp2_addrs.begin(), usrp2_addrs.end());
+    }
+    return device_addrs;
+}
+
+device::sptr device::make(const device_addr_t &hint, size_t which){
+    std::vector<device_addr_t> device_addrs = discover(hint);
+
+    //check that we found any devices
+    if (device_addrs.size() == 0){
+        throw std::runtime_error(str(
+            boost::format("No devices found for %s") % device_addr_to_string(hint)
+        ));
+    }
+
+    //check that the which index is valid
+    if (device_addrs.size() <= which){
+        throw std::runtime_error(str(
+            boost::format("No device at index %d for %s") % which % device_addr_to_string(hint)
+        ));
+    }
+
+    //create the new device with the discovered address
+    //TODO only a usrp device will be made (until others are supported)
+    if (true){
+        return sptr(new uhd::usrp::usrp(device_addrs.at(which)));
+    }
+    throw std::runtime_error("cant make a device");
+}
+
+device::device(void){
+    /* NOP */
+}
+
+device::~device(void){
+    /* NOP */
+}
diff --git a/host/lib/device_addr.cpp b/host/lib/device_addr.cpp
new file mode 100644
index 000000000..ffd511f92
--- /dev/null
+++ b/host/lib/device_addr.cpp
@@ -0,0 +1,86 @@
+//
+// 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/device_addr.hpp>
+#include <sstream>
+#include <cstring>
+#include <stdexcept>
+#include <boost/format.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/foreach.hpp>
+
+//----------------------- u2 mac addr wrapper ------------------------//
+uhd::mac_addr_t::mac_addr_t(const std::string &mac_addr_str_){
+    std::string mac_addr_str = (mac_addr_str_ == "")? "ff:ff:ff:ff:ff:ff" : mac_addr_str_;
+
+    //ether_aton_r(str.c_str(), &mac_addr);
+    uint8_t p[6] = {0x00, 0x50, 0xC2, 0x85, 0x30, 0x00}; // Matt's IAB
+
+    try{
+        //only allow patterns of xx:xx or xx:xx:xx:xx:xx:xx
+        //the IAB above will fill in for the shorter pattern
+        if (mac_addr_str.size() != 5 and mac_addr_str.size() != 17)
+            throw std::runtime_error("expected exactly 5 or 17 characters");
+
+        //split the mac addr hex string at the colons
+        std::vector<std::string> hex_strs;
+        boost::split(hex_strs, mac_addr_str, boost::is_any_of(":"));
+        for (size_t i = 0; i < hex_strs.size(); i++){
+            int hex_num;
+            std::istringstream iss(hex_strs[i]);
+            iss >> std::hex >> hex_num;
+            p[i] = uint8_t(hex_num);
+        }
+
+    }
+    catch(std::exception const& e){
+        throw std::runtime_error(str(
+            boost::format("Invalid mac address: %s\n\t%s") % mac_addr_str % e.what()
+        ));
+    }
+
+    memcpy(&mac_addr, p, sizeof(mac_addr));
+}
+
+std::string uhd::mac_addr_t::to_string(void) const{
+    //ether_ntoa_r(&mac_addr, addr_buf);
+    const uint8_t *p = reinterpret_cast<const uint8_t *>(&mac_addr);
+    return str(
+        boost::format("%02x:%02x:%02x:%02x:%02x:%02x")
+        % int(p[0]) % int(p[1]) % int(p[2])
+        % int(p[3]) % int(p[4]) % int(p[5])
+    );
+}
+
+std::ostream& operator<<(std::ostream &os, const uhd::mac_addr_t &x){
+    os << x.to_string();
+    return os;
+}
+
+//----------------------- usrp device_addr_t wrapper -------------------------//
+std::string uhd::device_addr_to_string(const uhd::device_addr_t &device_addr){
+    std::stringstream ss;
+    BOOST_FOREACH(std::string key, device_addr.get_keys()){
+        ss << boost::format("%s: %s") % key % device_addr[key] << std::endl;
+    }
+    return ss.str();
+}
+
+std::ostream& operator<<(std::ostream &os, const uhd::device_addr_t &device_addr){
+    os << uhd::device_addr_to_string(device_addr);
+    return os;
+}
diff --git a/host/lib/gain_handler.cpp b/host/lib/gain_handler.cpp
new file mode 100644
index 000000000..b03d5bda2
--- /dev/null
+++ b/host/lib/gain_handler.cpp
@@ -0,0 +1,167 @@
+//
+// 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/gain_handler.hpp>
+#include <uhd/utils.hpp>
+#include <boost/assign/list_of.hpp>
+#include <boost/foreach.hpp>
+#include <boost/format.hpp>
+#include <vector>
+
+using namespace uhd;
+
+/***********************************************************************
+ * Helper functions and macros
+ **********************************************************************/
+#define GET_PROP_NAMES() \
+    wax::cast<prop_names_t>((*_wax_obj_ptr)[_gain_names_prop])
+
+/*!
+ * Helper function to simplify getting a named gain (also min, max, step).
+ */
+static gain_t get_named_gain(wax::obj *wax_obj_ptr, wax::obj prop, std::string name){
+    return wax::cast<gain_t>((*wax_obj_ptr)[named_prop_t(prop, name)]);
+}
+
+/***********************************************************************
+ * Class methods of gain handler
+ **********************************************************************/
+gain_handler::~gain_handler(void){
+    /* NOP */
+}
+
+void gain_handler::_check_key(const wax::obj &key_){
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+    
+    try{
+        //only handle non wildcard names
+        ASSERT_THROW(name != "");
+
+        //only handle these gain props
+        ASSERT_THROW(
+            _is_equal(key, _gain_prop)     or
+            _is_equal(key, _gain_min_prop) or
+            _is_equal(key, _gain_max_prop) or
+            _is_equal(key, _gain_step_prop)
+        );
+
+        //check that the name is allowed
+        prop_names_t prop_names = GET_PROP_NAMES();
+        ASSERT_THROW(not std::has(prop_names.begin(), prop_names.end(), name));
+
+        //if we get here, throw an exception
+        throw std::invalid_argument(str(
+            boost::format("Unknown gain name %s") % name
+        ));
+    }
+    catch(const std::assert_error &){}
+}
+
+static gain_t gain_max(gain_t a, gain_t b){
+    return std::max(a, b);
+}
+static gain_t gain_sum(gain_t a, gain_t b){
+    return std::sum(a, b);
+}
+
+bool gain_handler::intercept_get(const wax::obj &key, wax::obj &val){
+    _check_key(key); //verify the key
+
+    std::vector<wax::obj> gain_props = boost::assign::list_of
+        (_gain_prop)(_gain_min_prop)(_gain_max_prop)(_gain_step_prop);
+
+    /*!
+     * Handle getting overall gains when a name is not specified.
+     * For the gain props below, set the overall value and return true. 
+     */
+    BOOST_FOREACH(wax::obj prop_key, gain_props){
+        if (_is_equal(key, prop_key)){
+            //form the gains vector from the props vector
+            prop_names_t prop_names = GET_PROP_NAMES();
+            std::vector<gain_t> gains(prop_names.size());
+            std::transform(
+                prop_names.begin(), prop_names.end(), gains.begin(),
+                boost::bind(get_named_gain, _wax_obj_ptr, key, _1)
+            );
+
+            //reduce across the gain vector
+            if (_is_equal(key, _gain_step_prop)){
+                val = std::reduce<gain_t>(gains.begin(), gains.end(), gain_max);
+            }
+            else{
+                val = std::reduce<gain_t>(gains.begin(), gains.end(), gain_sum);
+            }
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool gain_handler::intercept_set(const wax::obj &key_, const wax::obj &val){
+    _check_key(key_); //verify the key
+
+    wax::obj key; std::string name;
+    boost::tie(key, name) = extract_named_prop(key_);
+
+    /*!
+     * Verify that a named gain component is in range.
+     */
+    try{
+        //only handle the gain props
+        ASSERT_THROW(_is_equal(key, _gain_prop));
+
+        //check that the gain is in range
+        gain_t gain = wax::cast<gain_t>(val);
+        gain_t gain_min = get_named_gain(_wax_obj_ptr, _gain_min_prop,  name);
+        gain_t gain_max = get_named_gain(_wax_obj_ptr, _gain_max_prop,  name);
+        ASSERT_THROW(gain > gain_max or gain < gain_min);
+
+        //if we get here, throw an exception
+        throw std::range_error(str(
+            boost::format("gain %s is out of range of (%f, %f)") % name % gain_min % gain_max
+        ));
+    }
+    catch(const std::assert_error &){}
+
+    /*!
+     * Handle setting the overall gain.
+     */
+    if (_is_equal(key, _gain_prop) and name == ""){
+        gain_t gain = wax::cast<gain_t>(val);
+        prop_names_t prop_names = GET_PROP_NAMES();
+        BOOST_FOREACH(std::string name, prop_names){
+            //get the min, max, step for this gain name
+            gain_t gain_min  = get_named_gain(_wax_obj_ptr, _gain_min_prop,  name);
+            gain_t gain_max  = get_named_gain(_wax_obj_ptr, _gain_max_prop,  name);
+            gain_t gain_step = get_named_gain(_wax_obj_ptr, _gain_step_prop, name);
+
+            //clip g to be within the allowed range
+            gain_t g = std::min(std::max(gain, gain_min), gain_max);
+            //set g to be a multiple of the step size
+            g -= fmod(g, gain_step);
+            //set g to be the new gain
+            (*_wax_obj_ptr)[named_prop_t(_gain_prop, name)] = g;
+            //subtract g out of the total gain left to apply
+            gain -= g;
+        }
+        return true;
+    }
+
+    return false;
+}
diff --git a/host/lib/shared_iovec.cpp b/host/lib/shared_iovec.cpp
new file mode 100644
index 000000000..60062fbf0
--- /dev/null
+++ b/host/lib/shared_iovec.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/shared_iovec.hpp>
+
+uhd::shared_iovec::shared_iovec(size_t len_){
+    _shared_array = boost::shared_array<uint8_t>(new uint8_t[len_]);
+    base = _shared_array.get();
+    len = len_;
+}
+
+uhd::shared_iovec::~shared_iovec(void){
+    /* NOP */
+}
diff --git a/host/lib/transport/udp.cpp b/host/lib/transport/udp.cpp
new file mode 100644
index 000000000..06defb107
--- /dev/null
+++ b/host/lib/transport/udp.cpp
@@ -0,0 +1,67 @@
+//
+// 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/transport/udp.hpp>
+#include <boost/format.hpp>
+#include <boost/assign/list_of.hpp>
+#include <iostream>
+
+uhd::transport::udp::udp(const std::string &addr, const std::string &port, bool bcast){
+    //std::cout << boost::format("Creating udp transport for %s %s") % addr % port << std::endl;
+
+    // resolve the address
+    boost::asio::ip::udp::resolver resolver(_io_service);
+    boost::asio::ip::udp::resolver::query query(boost::asio::ip::udp::v4(), addr, port);
+    _receiver_endpoint = *resolver.resolve(query);
+
+    // Create and open the socket
+    _socket = new boost::asio::ip::udp::socket(_io_service);
+    _socket->open(boost::asio::ip::udp::v4());
+
+    if (bcast){
+        // Allow broadcasting
+        boost::asio::socket_base::broadcast option(true);
+        _socket->set_option(option);
+    }
+
+}
+
+uhd::transport::udp::~udp(void){
+    delete _socket;
+}
+
+void uhd::transport::udp::send(const std::vector<boost::asio::const_buffer> &buffs){
+    _socket->send_to(buffs, _receiver_endpoint);
+}
+
+void uhd::transport::udp::send(const boost::asio::const_buffer &buff){
+    std::vector<boost::asio::const_buffer> buffs = boost::assign::list_of(buff);
+    send(buffs);
+}
+
+uhd::shared_iovec uhd::transport::udp::recv(void){
+    //allocate a buffer for the number of bytes available (could be zero)
+    uhd::shared_iovec iov(_socket->available());
+    //call recv only if data is available
+    if (iov.len != 0){
+        _socket->receive_from(
+            boost::asio::buffer(iov.base, iov.len),
+            _sender_endpoint
+        );
+    }
+    return iov;
+}
diff --git a/host/lib/uhd.cpp b/host/lib/uhd.cpp
new file mode 100644
index 000000000..5e250c76f
--- /dev/null
+++ b/host/lib/uhd.cpp
@@ -0,0 +1,20 @@
+//
+// 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.hpp>
+
+//nothing here, just includes the header so the compiler can check
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();
+}
diff --git a/host/lib/wax.cpp b/host/lib/wax.cpp
new file mode 100644
index 000000000..c08398c50
--- /dev/null
+++ b/host/lib/wax.cpp
@@ -0,0 +1,146 @@
+//
+// 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/wax.hpp>
+#include <boost/format.hpp>
+#include <stdexcept>
+
+/*!
+ * The link args for internal use within this cpp file:
+ *
+ * It contains a link (in this case a pointer) to a wax object.
+ * Only the methods in this file may create or parse link args.
+ * The get_link method is the creator of a link args object.
+ * The [] operator will resolve the link and make the [] call.
+ *
+ * TODO: register the link args with the wax obj that it links to.
+ * That way, if the obj destructs, the link can be invalidated.
+ * The operator() will throw, rather than dereferencing bad memory.
+ */
+class link_args_t{
+public:
+    link_args_t(const wax::obj *obj_ptr) : _obj_ptr(obj_ptr){
+        /* NOP */
+    }
+    wax::obj & operator()(void){
+        return *const_cast<wax::obj *>(_obj_ptr);
+    }
+private:
+    const wax::obj *_obj_ptr;
+};
+
+/*!
+ * The proxy args for internal use within this cpp file:
+ *
+ * It contains a link and a key for setting/getting a property.
+ * Only the methods in this file may create or parse proxy args.
+ * Class methods have special handling for the case when the
+ * wax obj contains an instance of the proxy args.
+ */
+class proxy_args_t{
+public:
+    proxy_args_t(const wax::obj *obj_ptr, const wax::obj &key) : _key(key){
+        _obj_link = obj_ptr->get_link();
+    }
+    wax::obj & operator()(void){
+        return wax::cast<link_args_t>(_obj_link)();
+    }
+    const wax::obj & key(void){
+        return _key;
+    }
+private:
+    wax::obj _obj_link;
+    const wax::obj _key;
+};
+
+/***********************************************************************
+ * Structors
+ **********************************************************************/
+wax::obj::obj(void){
+    /* NOP */
+}
+
+wax::obj::obj(const obj &o){
+    _contents = o._contents;
+}
+
+wax::obj::~obj(void){
+    /* NOP */
+}
+
+/***********************************************************************
+ * Special Operators
+ **********************************************************************/
+wax::obj wax::obj::operator[](const obj &key){
+    if (_contents.type() == typeid(proxy_args_t)){
+        obj val = resolve();
+        //check if its a special link and call
+        if (val.type() == typeid(link_args_t)){
+            return cast<link_args_t>(val)()[key];
+        }
+        //unknown obj
+        throw std::runtime_error("cannot use [] on non wax::obj link");
+    }
+    else{
+        return proxy_args_t(this, key);
+    }
+}
+
+wax::obj & wax::obj::operator=(const obj &val){
+    if (_contents.type() == typeid(proxy_args_t)){
+        proxy_args_t proxy_args = boost::any_cast<proxy_args_t>(_contents);
+        proxy_args().set(proxy_args.key(), val);
+    }
+    else{
+        _contents = val._contents;
+    }
+    return *this;
+}
+
+/***********************************************************************
+ * Public Methods
+ **********************************************************************/
+wax::obj wax::obj::get_link(void) const{
+    return link_args_t(this);
+}
+
+const std::type_info & wax::obj::type(void) const{
+    return resolve().type();
+}
+
+/***********************************************************************
+ * Private Methods
+ **********************************************************************/
+boost::any wax::obj::resolve(void) const{
+    if (_contents.type() == typeid(proxy_args_t)){
+        obj val;
+        proxy_args_t proxy_args = boost::any_cast<proxy_args_t>(_contents);
+        proxy_args().get(proxy_args.key(), val);
+        return val.resolve();
+    }
+    else{
+        return _contents;
+    }
+}
+
+void wax::obj::get(const obj &, obj &){
+    throw std::runtime_error("Cannot call get on wax obj base class");
+}
+
+void wax::obj::set(const obj &, const obj &){
+    throw std::runtime_error("Cannot call set on wax obj base class");
+}
diff --git a/host/test/CMakeLists.txt b/host/test/CMakeLists.txt
new file mode 100644
index 000000000..0dcd1e68e
--- /dev/null
+++ b/host/test/CMakeLists.txt
@@ -0,0 +1,30 @@
+#
+# 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/>.
+#
+
+
+ADD_EXECUTABLE(main_test
+    main_test.cpp
+    addr_test.cpp
+    device_test.cpp
+    gain_handler_test.cpp
+    usrp_dboard_test.cpp
+    wax_test.cpp
+)
+
+TARGET_LINK_LIBRARIES(main_test uhd)
+
+ADD_TEST(test main_test)
diff --git a/host/test/addr_test.cpp b/host/test/addr_test.cpp
new file mode 100644
index 000000000..148aee015
--- /dev/null
+++ b/host/test/addr_test.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 <boost/test/unit_test.hpp>
+#include <uhd/device_addr.hpp>
+
+BOOST_AUTO_TEST_CASE(test_mac_addr){
+    std::cout << "Testing mac addr..." << std::endl;
+    const std::string mac_addr_str("00:01:23:45:67:89");
+    uhd::mac_addr_t mac_addr(mac_addr_str);
+    std::cout << "Input: " << mac_addr_str << std::endl;
+    std::cout << "Output: " << mac_addr << std::endl;
+    BOOST_CHECK_EQUAL(mac_addr_str, mac_addr.to_string());
+}
diff --git a/host/test/device_test.cpp b/host/test/device_test.cpp
new file mode 100644
index 000000000..6373ff41b
--- /dev/null
+++ b/host/test/device_test.cpp
@@ -0,0 +1,44 @@
+//
+// 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/test/unit_test.hpp>
+#include <uhd/device.hpp>
+
+using namespace uhd;
+
+BOOST_AUTO_TEST_CASE(test_device){
+    device_addr_t device_addr;
+    device_addr["type"] = "test";
+    device_addr["num_dboards"] = "2";
+    device::sptr dev = device::make(device_addr);
+
+    std::cout << "Access the device" << std::endl;
+    std::cout << wax::cast<std::string>((*dev)[DEVICE_PROP_NAME]) << std::endl;
+
+    std::cout << "Access the mboard" << std::endl;
+    wax::obj mb0 = (*dev)[DEVICE_PROP_MBOARD];
+    std::cout << wax::cast<std::string>(mb0[MBOARD_PROP_NAME]) << std::endl;
+    BOOST_CHECK_EQUAL(
+        2,
+        wax::cast<prop_names_t>(mb0[MBOARD_PROP_RX_DBOARD_NAMES]).size()
+    );
+    BOOST_CHECK_EQUAL(
+        2,
+        wax::cast<prop_names_t>(mb0[MBOARD_PROP_TX_DBOARD_NAMES]).size()
+    );
+
+}
diff --git a/host/test/gain_handler_test.cpp b/host/test/gain_handler_test.cpp
new file mode 100644
index 000000000..c81221aac
--- /dev/null
+++ b/host/test/gain_handler_test.cpp
@@ -0,0 +1,128 @@
+//
+// 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/test/unit_test.hpp>
+#include <uhd/gain_handler.hpp>
+#include <uhd/dict.hpp>
+#include <iostream>
+
+using namespace uhd;
+
+enum prop_t{
+    PROP_GAIN,
+    PROP_GAIN_MIN,
+    PROP_GAIN_MAX,
+    PROP_GAIN_STEP,
+    PROP_GAIN_NAMES
+};
+
+class gainful_obj : public wax::obj{
+public:
+    gainful_obj(void){
+        _gain_handler = gain_handler::sptr(new gain_handler(
+            this, PROP_GAIN, PROP_GAIN_MIN, PROP_GAIN_MAX, PROP_GAIN_STEP, PROP_GAIN_NAMES
+        ));
+        _gains["g0"] = 0;
+        _gains["g1"] = 0;
+        _gains_min["g0"] = -10;
+        _gains_min["g1"] = 0;
+        _gains_max["g0"] = 0;
+        _gains_max["g1"] = 100;
+        _gains_step["g0"] = .1;
+        _gains_step["g1"] = 1.5;
+    }
+
+    ~gainful_obj(void){}
+
+private:
+    void get(const wax::obj &key_, wax::obj &val){
+        if (_gain_handler->intercept_get(key_, val)) return;
+
+        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<prop_t>(key)){
+        case PROP_GAIN:
+            val = _gains[name];
+            return;
+
+        case PROP_GAIN_MIN:
+            val = _gains_min[name];
+            return;
+
+        case PROP_GAIN_MAX:
+            val = _gains_max[name];
+            return;
+
+        case PROP_GAIN_STEP:
+            val = _gains_step[name];
+            return;
+
+        case PROP_GAIN_NAMES:
+            val = prop_names_t(_gains.get_keys());
+            return;
+        }
+    }
+
+    void set(const wax::obj &key_, const wax::obj &val){
+        if (_gain_handler->intercept_set(key_, val)) return;
+
+        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<prop_t>(key)){
+        case PROP_GAIN:
+            _gains[name] = wax::cast<gain_t>(val);
+            return;
+
+        case PROP_GAIN_MIN:
+        case PROP_GAIN_MAX:
+        case PROP_GAIN_STEP:
+        case PROP_GAIN_NAMES:
+            throw std::runtime_error("cannot set this property");
+        }
+    }
+
+    gain_handler::sptr _gain_handler;
+    uhd::dict<std::string, gain_t> _gains;
+    uhd::dict<std::string, gain_t> _gains_min;
+    uhd::dict<std::string, gain_t> _gains_max;
+    uhd::dict<std::string, gain_t> _gains_step;
+
+};
+
+BOOST_AUTO_TEST_CASE(test_gain_handler){
+    std::cout << "Testing the gain handler..." << std::endl;
+    gainful_obj go0;
+
+    BOOST_CHECK_THROW(
+        wax::cast<gain_t>(go0[named_prop_t(PROP_GAIN, "fail")]),
+        std::invalid_argument
+    );
+
+    std::cout << "verifying the overall min, max, step" << std::endl;
+    BOOST_CHECK_EQUAL(wax::cast<gain_t>(go0[PROP_GAIN_MIN]), gain_t(-10));
+    BOOST_CHECK_EQUAL(wax::cast<gain_t>(go0[PROP_GAIN_MAX]), gain_t(100));
+    BOOST_CHECK_EQUAL(wax::cast<gain_t>(go0[PROP_GAIN_STEP]), gain_t(1.5));
+
+    std::cout << "verifying the overall gain" << std::endl;
+    go0[named_prop_t(PROP_GAIN, "g0")] = gain_t(-5);
+    go0[named_prop_t(PROP_GAIN, "g1")] = gain_t(30);
+    BOOST_CHECK_EQUAL(wax::cast<gain_t>(go0[PROP_GAIN]), gain_t(25));
+}
diff --git a/host/test/main_test.cpp b/host/test/main_test.cpp
new file mode 100644
index 000000000..0b47303b7
--- /dev/null
+++ b/host/test/main_test.cpp
@@ -0,0 +1,3 @@
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
diff --git a/host/test/usrp_dboard_test.cpp b/host/test/usrp_dboard_test.cpp
new file mode 100644
index 000000000..f0ae7a53d
--- /dev/null
+++ b/host/test/usrp_dboard_test.cpp
@@ -0,0 +1,60 @@
+//
+// 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/test/unit_test.hpp>
+#include <uhd/usrp/dboard/manager.hpp>
+
+using namespace uhd::usrp::dboard;
+
+/***********************************************************************
+ * dummy interface for dboards
+ **********************************************************************/
+class dummy_interface : public 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;}
+};
+
+BOOST_AUTO_TEST_CASE(test_manager){
+    std::cout << "Making a dummy usrp dboard interface..." << std::endl;
+    interface::sptr ifc0(new dummy_interface());
+
+    std::cout << "Making a usrp dboard manager..." << std::endl;
+    manager::sptr mgr0(new manager(ID_BASIC_RX, ID_BASIC_TX, ifc0));
+
+    std::cout << "Testing the dboard manager..." << std::endl;
+    BOOST_CHECK_EQUAL(size_t(3), mgr0->get_rx_subdev_names().size());
+    BOOST_CHECK_EQUAL(size_t(1), mgr0->get_tx_subdev_names().size());
+
+    std::cout << "Testing access (will fail later when db code filled in)..." << std::endl;
+    BOOST_CHECK_THROW(mgr0->get_rx_subdev(""), std::invalid_argument);
+    BOOST_CHECK_THROW(mgr0->get_tx_subdev("x"), std::invalid_argument);
+    mgr0->get_rx_subdev("a")[0];
+    mgr0->get_tx_subdev("")[0];
+}
diff --git a/host/test/wax_test.cpp b/host/test/wax_test.cpp
new file mode 100644
index 000000000..e5e1adc25
--- /dev/null
+++ b/host/test/wax_test.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 <boost/test/unit_test.hpp>
+#include <uhd/wax.hpp>
+
+enum opt_a_t{OPTION_A_0, OPTION_A_1};
+enum opt_b_t{OPTION_B_0, OPTION_B_1};
+
+BOOST_AUTO_TEST_CASE(test_enums){
+    wax::obj opta = OPTION_A_0;
+    BOOST_CHECK_THROW(wax::cast<opt_b_t>(opta), wax::bad_cast);
+    BOOST_CHECK_EQUAL(wax::cast<opt_a_t>(opta), OPTION_A_0);
+}
+
+/***********************************************************************
+ * demo class for wax framework
+ **********************************************************************/
+class wax_demo : public wax::obj{
+private:
+    std::vector<float> d_nums;
+    std::vector<wax_demo> d_subs;
+public:
+    wax_demo(size_t sub_demos, size_t len){
+        d_nums = std::vector<float>(len);
+        if (sub_demos != 0){
+            for (size_t i = 0; i < len; i++){
+                d_subs.push_back(wax_demo(sub_demos-1, len));
+            }
+        }
+    }
+    ~wax_demo(void){
+        /* NOP */
+    }
+    void get(const wax::obj &key, wax::obj &value){
+        if (d_subs.size() == 0){
+            value = d_nums[wax::cast<size_t>(key)];
+        }else{
+            value = d_subs[wax::cast<size_t>(key)].get_link();
+        }
+    }
+    void set(const wax::obj &key, const wax::obj &value){
+        if (d_subs.size() == 0){
+            d_nums[wax::cast<size_t>(key)] = wax::cast<float>(value);
+        }else{
+            throw std::runtime_error("cant set to a wax demo with sub demos");
+        }
+    }
+};
+
+static wax_demo wd(2, 10);
+
+BOOST_AUTO_TEST_CASE(test_chaining){
+    std::cout << "chain 1" << std::endl;
+    wd[size_t(0)];
+    std::cout << "chain 2" << std::endl;
+    wd[size_t(0)][size_t(0)];
+    std::cout << "chain 3" << std::endl;
+    wd[size_t(0)][size_t(0)][size_t(0)];
+}
+
+BOOST_AUTO_TEST_CASE(test_set_get){
+    std::cout << "set and get all" << std::endl;
+    for (size_t i = 0; i < 10; i++){
+        for (size_t j = 0; j < 10; j++){
+            for (size_t k = 0; k < 10; k++){
+                float val = i * j * k + i + j + k;
+                //std::cout << i << " " << j << " " << k << std::endl;
+                wd[i][j][k] = val;
+                BOOST_CHECK_EQUAL(val, wax::cast<float>(wd[i][j][k]));
+            }
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_proxy){
+    std::cout << "store proxy" << std::endl;
+    wax::obj p = wd[size_t(0)][size_t(0)];
+    p[size_t(0)] = float(5);
+
+    std::cout << "assign proxy" << std::endl;
+    wax::obj a = p[size_t(0)];
+    BOOST_CHECK_EQUAL(wax::cast<float>(a), float(5));
+}
diff --git a/host/uhd.pc.in b/host/uhd.pc.in
new file mode 100644
index 000000000..59ba623f5
--- /dev/null
+++ b/host/uhd.pc.in
@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+libdir=${prefix}/@LIBRARY_DIR@
+includedir=${prefix}/@HEADER_DIR@
+
+Name: @CPACK_PACKAGE_NAME@
+Description: Universal Hardware Driver
+Requires:
+Version: @CPACK_PACKAGE_VERSION@
+Libs: -L${libdir} -luhd
+Cflags: -I${includedir}