Merge branch 'u1e_uhd' of ettus.sourcerepo.com:ettus/uhd into u1e_uhd

25 files changed, 1080 insertions, 201 deletions

diff --git a/host/CMakeLists.txt b/host/CMakeLists.txt
index 70c04631b..30f4789a3 100644
--- a/host/CMakeLists.txt
+++ b/host/CMakeLists.txt
@@ -73,6 +73,15 @@ INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIRS})
 LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
 
 ########################################################################
+# Setup Endianess
+########################################################################
+INCLUDE(TestBigEndian)
+TEST_BIG_ENDIAN(HAVE_BIG_ENDIAN)
+IF(HAVE_BIG_ENDIAN)
+    ADD_DEFINITIONS("-DHAVE_BIG_ENDIAN=/* */")
+ENDIF(HAVE_BIG_ENDIAN)
+
+########################################################################
 # Create Uninstall Target
 ########################################################################
 CONFIGURE_FILE(
diff --git a/host/apps/CMakeLists.txt b/host/apps/CMakeLists.txt
index f4428f958..a7068e5a4 100644
--- a/host/apps/CMakeLists.txt
+++ b/host/apps/CMakeLists.txt
@@ -16,7 +16,9 @@
 #
 
 ADD_EXECUTABLE(discover_usrps discover_usrps.cpp)
-
 TARGET_LINK_LIBRARIES(discover_usrps uhd)
 
+ADD_EXECUTABLE(usrp1e_load_fpga usrp1e_load_fpga.cpp)
+TARGET_LINK_LIBRARIES(usrp1e_load_fpga uhd)
+
 INSTALL(TARGETS discover_usrps RUNTIME DESTINATION ${RUNTIME_DIR})
diff --git a/host/apps/discover_usrps.cpp b/host/apps/discover_usrps.cpp
index 02c05b7cc..7e8c21673 100644
--- a/host/apps/discover_usrps.cpp
+++ b/host/apps/discover_usrps.cpp
@@ -22,13 +22,13 @@
 #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")
+        ("addr", po::value<std::string>(), "resolvable network address")
+        ("node", po::value<std::string>(), "path to linux device node")
     ;
 
     po::variables_map vm;
@@ -36,30 +36,35 @@ int main(int argc, char *argv[]){
     po::notify(vm); 
 
     //print the help message
-    if (vm.count("help")) {
+    if (vm.count("help")){
         std::cout << boost::format("Discover USRPs %s") % desc << std::endl;
         return ~0;
     }
 
-    //extract the ip address (not optional for now)
+    //load the options into the address
     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;
+    if (vm.count("addr")){
+        device_addr["addr"] = vm["addr"].as<std::string>();
+    }
+    if (vm.count("node")){
+        device_addr["node"] = vm["node"].as<std::string>();
+    }
+
+    //discover the usrps and print the results
+    uhd::device_addrs_t device_addrs = uhd::device::discover(device_addr);
+
+    if (device_addrs.size() == 0){
+        std::cerr << "No USRP Devices Found" << 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)
-        uhd::device::sptr dev = device::make(device_addrs[i]);
+        uhd::device::sptr dev = uhd::device::make(device_addrs[i]);
         std::cout << wax::cast<std::string>((*dev)[uhd::DEVICE_PROP_MBOARD][uhd::MBOARD_PROP_NAME]) << std::endl;
     }
 
diff --git a/host/apps/usrp1e_load_fpga.cpp b/host/apps/usrp1e_load_fpga.cpp
new file mode 100644
index 000000000..d5960b391
--- /dev/null
+++ b/host/apps/usrp1e_load_fpga.cpp
@@ -0,0 +1,47 @@
+//
+// 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/usrp1e.hpp>
+#include <boost/program_options.hpp>
+#include <boost/format.hpp>
+#include <iostream>
+
+namespace po = boost::program_options;
+
+int main(int argc, char *argv[]){
+    po::options_description desc("Allowed options");
+    desc.add_options()
+        ("help", "help message")
+        ("file", po::value<std::string>(), "path to fpga bin file")
+    ;
+
+    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") or vm.count("file") == 0){
+        std::cout << boost::format("USRP1E Load FPGA %s") % desc << std::endl;
+        return ~0;
+    }
+
+    //load the fpga
+    std::string file = vm["file"].as<std::string>();
+    uhd::usrp::usrp1e::load_fpga(file);
+
+    return 0;
+}
diff --git a/host/include/uhd/CMakeLists.txt b/host/include/uhd/CMakeLists.txt
index 006c54f22..f4fb96786 100644
--- a/host/include/uhd/CMakeLists.txt
+++ b/host/include/uhd/CMakeLists.txt
@@ -24,8 +24,8 @@ INSTALL(FILES
     device_addr.hpp
     dict.hpp
     gain_handler.hpp
+    metadata.hpp
     props.hpp
-    shared_iovec.hpp
     time_spec.hpp
     utils.hpp
     wax.hpp
diff --git a/host/include/uhd/device.hpp b/host/include/uhd/device.hpp
index dfbfbd7c0..ba5337d33 100644
--- a/host/include/uhd/device.hpp
+++ b/host/include/uhd/device.hpp
@@ -20,13 +20,12 @@
 
 #include <uhd/device_addr.hpp>
 #include <uhd/props.hpp>
+#include <uhd/metadata.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{
 
@@ -39,10 +38,6 @@ 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.
      *
@@ -72,9 +67,33 @@ public:
      */
     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;
+    /*!
+     * Send a buffer containing IF data with its metadata.
+     *
+     * \param buff a buffer pointing to some read-only memory
+     * \param metadata data describing the buffer's contents
+     * \param the type of data loaded in the buffer (32fc, 16sc)
+     * \return the number of samples sent
+     */
+    virtual size_t send(
+        const boost::asio::const_buffer &buff,
+        const metadata_t &metadata,
+        const std::string &type = "32fc"
+    ) = 0;
+
+    /*!
+     * Receive a buffer containing IF data and its metadata.
+     *
+     * \param buff the buffer to fill with IF data
+     * \param metadata data to fill describing the buffer
+     * \param the type of data to fill into the buffer (32fc, 16sc)
+     * \return the number of samples received
+     */
+    virtual size_t recv(
+        const boost::asio::mutable_buffer &buff,
+        metadata_t &metadata,
+        const std::string &type = "32fc"
+    ) = 0;
 };
 
 } //namespace uhd
diff --git a/host/include/uhd/device_addr.hpp b/host/include/uhd/device_addr.hpp
index 8ea580321..d02febd6c 100644
--- a/host/include/uhd/device_addr.hpp
+++ b/host/include/uhd/device_addr.hpp
@@ -56,7 +56,9 @@ namespace uhd{
      * \param device_addr a device address instance
      * \return the string representation
      */
-    std::string device_addr_to_string(const device_addr_t &device_addr);
+    struct device_addr{
+        static std::string to_string(const device_addr_t &device_addr);
+    };
 
 } //namespace uhd
 
diff --git a/host/include/uhd/metadata.hpp b/host/include/uhd/metadata.hpp
new file mode 100644
index 000000000..70842e7bc
--- /dev/null
+++ b/host/include/uhd/metadata.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_METADATA_HPP
+#define INCLUDED_UHD_METADATA_HPP
+
+#include <uhd/time_spec.hpp>
+
+namespace uhd{
+
+/*!
+ * Metadata structure for describing the IF data.
+ * Includes stream ID, time specification, and burst flags.
+ * The receive routines will convert IF data headers into metadata.
+ * The send routines will convert the metadata to IF data headers.
+ */
+struct metadata_t{
+    uint32_t stream_id;
+    bool has_stream_id;
+    time_spec_t time_spec;
+    bool has_time_spec;
+    bool start_of_burst;
+    bool end_of_burst;
+
+    metadata_t(void){
+        stream_id = 0;
+        has_stream_id = false;
+        time_spec = time_spec_t();
+        has_time_spec = false;
+        start_of_burst = false;
+        end_of_burst = false;
+    }
+};
+
+} //namespace uhd
+
+#endif /* INCLUDED_UHD_METADATA_HPP */
diff --git a/host/include/uhd/shared_iovec.hpp b/host/include/uhd/shared_iovec.hpp
deleted file mode 100644
index a120e55d5..000000000
--- a/host/include/uhd/shared_iovec.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// 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/transport/udp.hpp b/host/include/uhd/transport/udp.hpp
index 6db6bd377..8c6fb096f 100644
--- a/host/include/uhd/transport/udp.hpp
+++ b/host/include/uhd/transport/udp.hpp
@@ -18,7 +18,6 @@
 #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
@@ -30,44 +29,46 @@ public:
     typedef boost::shared_ptr<udp> sptr;
 
     /*!
-     * Constructor.
+     * Make a new udp transport.
      * 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);
+    static sptr make(const std::string &addr, const std::string &port, bool bcast = false);
 
     /*!
      * Send a vector of buffer (like send_msg).
+     * Blocks until the data is sent.
      * \param buffs a vector of asio buffers
+     * \return the number of bytes sent
      */
-    void send(const std::vector<boost::asio::const_buffer> &buffs);
+    virtual size_t send(const std::vector<boost::asio::const_buffer> &buffs) = 0;
 
     /*!
      * Send a single buffer.
+     * Blocks until the data is sent.
      * \param buff single asio buffer
+     * \return the number of bytes sent
      */
-    void send(const boost::asio::const_buffer &buff);
+    virtual size_t send(const boost::asio::const_buffer &buff) = 0;
 
     /*!
-     * 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
+     * Receive a buffer. Write into the memory provided.
+     * Returns empty when data is not available.
+     * \param buffs a vector of asio buffers
+     * \return the number of bytes received.
      */
-    uhd::shared_iovec recv(void);
+    virtual size_t recv(const std::vector<boost::asio::mutable_buffer> &buffs) = 0;
 
-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;
+    /*!
+     * Receive a buffer. Write into the memory provided.
+     * Returns empty when data is not available.
+     * \param buff a mutable buffer to receive into
+     * \return the number of bytes received.
+     */
+    virtual size_t recv(const boost::asio::mutable_buffer &buff) = 0;
 };
 
 }} //namespace
diff --git a/host/include/uhd/usrp/CMakeLists.txt b/host/include/uhd/usrp/CMakeLists.txt
index e7bdc1784..4e0a92365 100644
--- a/host/include/uhd/usrp/CMakeLists.txt
+++ b/host/include/uhd/usrp/CMakeLists.txt
@@ -21,6 +21,7 @@ INSTALL(FILES
     dboard_id.hpp
     dboard_interface.hpp
     dboard_manager.hpp
+    usrp1e.hpp
     usrp2.hpp
     DESTINATION ${HEADER_DIR}/uhd/usrp
 )
diff --git a/host/include/uhd/usrp/usrp1e.hpp b/host/include/uhd/usrp/usrp1e.hpp
new file mode 100644
index 000000000..60a6a191a
--- /dev/null
+++ b/host/include/uhd/usrp/usrp1e.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_USRP_USRP1E_HPP
+#define INCLUDED_UHD_USRP_USRP1E_HPP
+
+#include <uhd/device.hpp>
+
+namespace uhd{ namespace usrp{
+
+/*!
+ * The usrp1e device class.
+ */
+class usrp1e : public device{
+public:
+    /*!
+     * Discover usrp1e devices on the system via the device node.
+     * This static method will be called by the device::discover.
+     * \param hint a device addr with the usrp1e address filled in
+     * \return a vector of device addresses for all usrp1es found
+     */
+    static device_addrs_t discover(const device_addr_t &hint);
+
+    /*!
+     * Make a usrp1e from a device address.
+     * \param addr the device address
+     * \return a device sptr to a new usrp1e
+     */
+    static device::sptr make(const device_addr_t &addr);
+
+    /*!
+     * Load the FPGA with an image file.
+     * \param bin_file the name of the fpga image file
+     */
+    static void load_fpga(const std::string &bin_file);
+};
+
+}} //namespace
+
+#endif /* INCLUDED_UHD_USRP_USRP1E_HPP */
diff --git a/host/include/uhd/usrp/usrp2.hpp b/host/include/uhd/usrp/usrp2.hpp
index f6e49cbd6..da7ec595a 100644
--- a/host/include/uhd/usrp/usrp2.hpp
+++ b/host/include/uhd/usrp/usrp2.hpp
@@ -15,8 +15,8 @@
 // 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
+#ifndef INCLUDED_UHD_USRP_USRP2_HPP
+#define INCLUDED_UHD_USRP_USRP2_HPP
 
 #include <uhd/device.hpp>
 
@@ -45,4 +45,4 @@ public:
 
 }} //namespace
 
-#endif /* INCLUDED_UHD_USRP_MBOARD_USRP2_HPP */
+#endif /* INCLUDED_UHD_USRP_USRP2_HPP */
diff --git a/host/lib/CMakeLists.txt b/host/lib/CMakeLists.txt
index 5cf334678..33314e729 100644
--- a/host/lib/CMakeLists.txt
+++ b/host/lib/CMakeLists.txt
@@ -15,12 +15,13 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-
+########################################################################
+# Create a list of libuhd sources
+########################################################################
 SET(libuhd_sources
     device.cpp
     device_addr.cpp
     gain_handler.cpp
-    shared_iovec.cpp
     uhd.cpp
     wax.cpp
     transport/udp.cpp
@@ -32,10 +33,40 @@ SET(libuhd_sources
     usrp/usrp2/dboard_impl.cpp
     usrp/usrp2/dboard_interface.cpp
     usrp/usrp2/dsp_impl.cpp
+    usrp/usrp2/io_impl.cpp
     usrp/usrp2/mboard_impl.cpp
     usrp/usrp2/usrp2_impl.cpp
 )
 
+########################################################################
+# Conditionally add the usrp1e sources
+########################################################################
+INCLUDE(CheckIncludeFiles)
+SET(usrp1e_required_headers
+    linux/ioctl.h
+    linux/spi/spidev.h
+)
+CHECK_INCLUDE_FILES(
+    "${usrp1e_required_headers}"
+    HAS_USRP1E_REQUIRED_HEADERS
+)
+
+IF(HAS_USRP1E_REQUIRED_HEADERS)
+    MESSAGE(STATUS "Building usrp1e support...")
+    LIST(APPEND libuhd_sources
+        usrp/usrp1e/fpga-downloader.cc
+        usrp/usrp1e/usrp1e_impl.cpp
+    )
+ELSE(HAS_USRP1E_REQUIRED_HEADERS)
+    MESSAGE(STATUS "Skipping usrp1e support...")
+    LIST(APPEND libuhd_sources
+        usrp/usrp1e/usrp1e_none.cpp
+    )
+ENDIF(HAS_USRP1E_REQUIRED_HEADERS)
+
+########################################################################
+# Setup libuhd library
+########################################################################
 ADD_LIBRARY(uhd SHARED ${libuhd_sources})
 
 TARGET_LINK_LIBRARIES(uhd ${Boost_LIBRARIES})
diff --git a/host/lib/device.cpp b/host/lib/device.cpp
index e376a5c50..82052708a 100644
--- a/host/lib/device.cpp
+++ b/host/lib/device.cpp
@@ -12,57 +12,122 @@
 // 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/>.
+// asize_t with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
+#include <uhd/usrp/usrp1e.hpp>
 #include <uhd/usrp/usrp2.hpp>
-#include <uhd/device.hpp>
+#include <uhd/dict.hpp>
+#include <uhd/utils.hpp>
+#include <boost/foreach.hpp>
 #include <boost/format.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/functional/hash.hpp>
 #include <stdexcept>
+#include <algorithm>
 
 using namespace uhd;
 
+/*!
+ * Create a new device from a device address.
+ * Based on the address, call the appropriate make functions.
+ * \param dev_addr the device address
+ * \return a smart pointer to a device
+ */
+static device::sptr make_device(const device_addr_t &dev_addr){
+
+    //create a usrp1e
+    if (dev_addr["type"] == "usrp1e"){
+        return usrp::usrp1e::make(dev_addr);
+    }
+
+    //create a usrp2
+    if (dev_addr["type"] == "usrp2"){
+        return usrp::usrp2::make(dev_addr);
+    }
+
+    throw std::runtime_error("cant make a device");
+}
+
+/*!
+ * Make a device hash that maps 1 to 1 with a device address.
+ * The hash will be used to identify created devices.
+ * \param dev_addr the device address
+ * \return the hash number
+ */
+static size_t hash_device_addr(
+    const device_addr_t &dev_addr
+){
+    //sort the keys of the device address
+    std::vector<std::string> keys = dev_addr.get_keys();
+    std::sort(keys.begin(), keys.end());
+
+    //combine the hashes of sorted keys/value pairs
+    size_t hash = 0;
+    BOOST_FOREACH(std::string key, keys){
+        boost::hash_combine(hash, key);
+        boost::hash_combine(hash, dev_addr[key]);
+    }
+    return hash;
+}
+
+/***********************************************************************
+ * Discover
+ **********************************************************************/
 device_addrs_t device::discover(const device_addr_t &hint){
     device_addrs_t device_addrs;
-    if (not hint.has_key("type")){
-        //TODO call discover for others and append results
-    }
-    else if (hint["type"] == "udp"){
+
+    //discover the usrp1es
+    std::vector<device_addr_t> usrp2_addrs = usrp::usrp1e::discover(hint);
+    device_addrs.insert(device_addrs.begin(), usrp2_addrs.begin(), usrp2_addrs.end());
+
+    //discover the usrp2s
+    if (hint.has_key("addr")){
         std::vector<device_addr_t> usrp2_addrs = usrp::usrp2::discover(hint);
         device_addrs.insert(device_addrs.begin(), usrp2_addrs.begin(), usrp2_addrs.end());
     }
+
     return device_addrs;
 }
 
+/***********************************************************************
+ * Make
+ **********************************************************************/
 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)
+            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)
+            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 usrp2 device will be made (until others are supported)
-    if (hint.has_key("type") and hint["type"] == "udp"){
-        return usrp::usrp2::make(device_addrs.at(which));
-    }
-    throw std::runtime_error("cant make a device");
-}
+    //create a unique hash for the device address
+    device_addr_t dev_addr = device_addrs.at(which);
+    size_t dev_hash = hash_device_addr(dev_addr);
+    //std::cout << boost::format("Hash: %u") % dev_hash << std::endl;
 
-device::device(void){
-    /* NOP */
-}
+    //map device address hash to created devices
+    static uhd::dict<size_t, boost::weak_ptr<device> > hash_to_device;
 
-device::~device(void){
-    /* NOP */
+    //try to find an existing device
+    try{
+        ASSERT_THROW(hash_to_device.has_key(dev_hash));
+        ASSERT_THROW(not hash_to_device[dev_hash].expired());
+        return hash_to_device[dev_hash].lock();
+    }
+    //create and register a new device
+    catch(const std::assert_error &e){
+        device::sptr dev = make_device(dev_addr);
+        hash_to_device[dev_hash] = dev;
+        return dev;
+    }
 }
diff --git a/host/lib/device_addr.cpp b/host/lib/device_addr.cpp
index ffd511f92..9514df981 100644
--- a/host/lib/device_addr.cpp
+++ b/host/lib/device_addr.cpp
@@ -72,7 +72,7 @@ std::ostream& operator<<(std::ostream &os, const uhd::mac_addr_t &x){
 }
 
 //----------------------- usrp device_addr_t wrapper -------------------------//
-std::string uhd::device_addr_to_string(const uhd::device_addr_t &device_addr){
+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;
@@ -81,6 +81,6 @@ std::string uhd::device_addr_to_string(const uhd::device_addr_t &device_addr){
 }
 
 std::ostream& operator<<(std::ostream &os, const uhd::device_addr_t &device_addr){
-    os << uhd::device_addr_to_string(device_addr);
+    os << uhd::device_addr::to_string(device_addr);
     return os;
 }
diff --git a/host/lib/transport/udp.cpp b/host/lib/transport/udp.cpp
index 06defb107..878f71410 100644
--- a/host/lib/transport/udp.cpp
+++ b/host/lib/transport/udp.cpp
@@ -17,10 +17,45 @@
 
 #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){
+/***********************************************************************
+ * UDP implementation class
+ **********************************************************************/
+class udp_impl : public uhd::transport::udp{
+public:
+    //structors
+    udp_impl(const std::string &addr, const std::string &port, bool bcast);
+    ~udp_impl(void);
+
+    //send/recv
+    size_t send(const std::vector<boost::asio::const_buffer> &buffs);
+    size_t send(const boost::asio::const_buffer &buff);
+    size_t recv(const std::vector<boost::asio::mutable_buffer> &buffs);
+    size_t recv(const boost::asio::mutable_buffer &buff);
+
+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;
+};
+
+/***********************************************************************
+ * UDP public make function
+ **********************************************************************/
+uhd::transport::udp::sptr uhd::transport::udp::make(
+    const std::string &addr,
+    const std::string &port,
+    bool bcast
+){
+    return uhd::transport::udp::sptr(new udp_impl(addr, port, bcast));
+}
+
+/***********************************************************************
+ * UDP implementation methods
+ **********************************************************************/
+udp_impl::udp_impl(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
@@ -40,28 +75,24 @@ uhd::transport::udp::udp(const std::string &addr, const std::string &port, bool
 
 }
 
-uhd::transport::udp::~udp(void){
+udp_impl::~udp_impl(void){
     delete _socket;
 }
 
-void uhd::transport::udp::send(const std::vector<boost::asio::const_buffer> &buffs){
-    _socket->send_to(buffs, _receiver_endpoint);
+size_t udp_impl::send(const std::vector<boost::asio::const_buffer> &buffs){
+    return _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);
+size_t udp_impl::send(const boost::asio::const_buffer &buff){
+    return _socket->send_to(boost::asio::buffer(buff), _receiver_endpoint);
 }
 
-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;
+size_t udp_impl::recv(const std::vector<boost::asio::mutable_buffer> &buffs){
+    if (_socket->available() == 0) return 0;
+    return _socket->receive_from(buffs, _sender_endpoint);
+}
+
+size_t udp_impl::recv(const boost::asio::mutable_buffer &buff){
+    if (_socket->available() == 0) return 0;
+    return _socket->receive_from(boost::asio::buffer(buff), _sender_endpoint);
 }
diff --git a/host/lib/usrp/dboard_manager.cpp b/host/lib/usrp/dboard_manager.cpp
index f0846db25..cce239f3e 100644
--- a/host/lib/usrp/dboard_manager.cpp
+++ b/host/lib/usrp/dboard_manager.cpp
@@ -91,6 +91,8 @@ private:
     //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;
+    dboard_interface::sptr _interface;
+    void set_nice_gpio_pins(void);
 };
 
 /***********************************************************************
@@ -184,6 +186,7 @@ dboard_manager_impl::dboard_manager_impl(
     dboard_interface::sptr interface
 ){
     register_internal_dboards(); //always call first
+    _interface = interface;
 
     dboard_ctor_t rx_dboard_ctor; prop_names_t rx_subdevs;
     boost::tie(rx_dboard_ctor, rx_subdevs) = get_dboard_args(rx_dboard_id, "rx");
@@ -192,14 +195,7 @@ dboard_manager_impl::dboard_manager_impl(
     boost::tie(tx_dboard_ctor, tx_subdevs) = get_dboard_args(tx_dboard_id, "tx");
 
     //initialize the gpio pins before creating subdevs
-    interface->set_gpio_ddr(dboard_interface::GPIO_RX_BANK, 0x0000, 0xffff); //all inputs
-    interface->set_gpio_ddr(dboard_interface::GPIO_TX_BANK, 0x0000, 0xffff);
-
-    interface->write_gpio(dboard_interface::GPIO_RX_BANK, 0x0000, 0xffff); //all zeros
-    interface->write_gpio(dboard_interface::GPIO_TX_BANK, 0x0000, 0xffff);
-
-    interface->set_atr_reg(dboard_interface::GPIO_RX_BANK, 0x0000, 0x0000, 0x0000); //software controlled
-    interface->set_atr_reg(dboard_interface::GPIO_TX_BANK, 0x0000, 0x0000, 0x0000);
+    set_nice_gpio_pins();
 
     //make xcvr subdevs (make one subdev for both rx and tx dboards)
     if (rx_dboard_ctor == tx_dboard_ctor){
@@ -245,7 +241,7 @@ dboard_manager_impl::dboard_manager_impl(
 }
 
 dboard_manager_impl::~dboard_manager_impl(void){
-    /* NOP */
+    set_nice_gpio_pins();
 }
 
 prop_names_t dboard_manager_impl::get_rx_subdev_names(void){
@@ -271,3 +267,16 @@ wax::obj dboard_manager_impl::get_tx_subdev(const std::string &subdev_name){
     //get a link to the tx subdev proxy
     return wax::cast<subdev_proxy::sptr>(_tx_dboards[subdev_name])->get_link();
 }
+
+void dboard_manager_impl::set_nice_gpio_pins(void){
+    //std::cout << "Set nice GPIO pins" << std::endl;
+
+    _interface->set_gpio_ddr(dboard_interface::GPIO_RX_BANK, 0x0000, 0xffff); //all inputs
+    _interface->set_gpio_ddr(dboard_interface::GPIO_TX_BANK, 0x0000, 0xffff);
+
+    _interface->write_gpio(dboard_interface::GPIO_RX_BANK, 0x0000, 0xffff); //all zeros
+    _interface->write_gpio(dboard_interface::GPIO_TX_BANK, 0x0000, 0xffff);
+
+    _interface->set_atr_reg(dboard_interface::GPIO_RX_BANK, 0x0000, 0x0000, 0x0000); //software controlled
+    _interface->set_atr_reg(dboard_interface::GPIO_TX_BANK, 0x0000, 0x0000, 0x0000);
+}
diff --git a/host/lib/usrp/usrp1e/fpga-downloader.cc b/host/lib/usrp/usrp1e/fpga-downloader.cc
new file mode 100644
index 000000000..f7c78b875
--- /dev/null
+++ b/host/lib/usrp/usrp1e/fpga-downloader.cc
@@ -0,0 +1,262 @@
+//
+// 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>
+#include <sstream>
+#include <fstream>
+#include <string>
+#include <cstdlib>
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+
+#include <linux/spi/spidev.h>
+
+/*
+ * Configuration connections
+ *
+ * CCK    - MCSPI1_CLK
+ * DIN    - MCSPI1_MOSI
+ * PROG_B - GPIO_175     - output (change mux)
+ * DONE   - GPIO_173     - input  (change mux)
+ * INIT_B - GPIO_114     - input  (change mux)
+ *
+*/
+
+const unsigned int PROG_B = 175;
+const unsigned int DONE   = 173;
+const unsigned int INIT_B = 114;
+
+//static std::string bit_file = "safe_u1e.bin";
+
+const int BUF_SIZE = 4096;
+
+enum gpio_direction {IN, OUT};
+
+class gpio {
+	public:
+
+	gpio(unsigned int gpio_num, gpio_direction pin_direction);
+
+	bool get_value();
+	void set_value(bool state);
+
+	private:
+
+	std::stringstream base_path;
+	std::fstream value_file;	
+};
+
+class spidev {
+	public:
+
+	spidev(std::string dev_name);
+	~spidev();
+
+	void send(char *wbuf, char *rbuf, unsigned int nbytes);
+
+	private:
+
+	int fd;
+
+};
+
+gpio::gpio(unsigned int gpio_num, gpio_direction pin_direction)
+{
+	std::fstream export_file;
+
+	export_file.open("/sys/class/gpio/export", std::ios::out);
+	if (!export_file.is_open())  ///\todo Poor error handling
+		std::cout << "Failed to open gpio export file." << std::endl;
+
+	export_file << gpio_num << std::endl;
+
+	base_path << "/sys/class/gpio/gpio" << gpio_num << std::flush;
+
+	std::fstream direction_file;
+	std::string direction_file_name;
+
+	direction_file_name = base_path.str() + "/direction";
+
+	direction_file.open(direction_file_name.c_str()); 
+	if (!direction_file.is_open())
+		std::cout << "Failed to open direction file." << std::endl;
+	if (pin_direction == OUT)
+		direction_file << "out" << std::endl;
+	else
+		direction_file << "in" << std::endl;
+
+	std::string value_file_name;
+
+	value_file_name = base_path.str() + "/value";
+
+	value_file.open(value_file_name.c_str(), std::ios_base::in | std::ios_base::out);
+	if (!value_file.is_open())
+		std::cout << "Failed to open value file." << std::endl;
+}
+
+bool gpio::get_value()
+{
+
+	std::string val;
+
+	std::getline(value_file, val);
+	value_file.seekg(0);
+
+	if (val == "0")
+		return false;
+	else if (val == "1")
+		return true;
+	else
+		std::cout << "Data read from value file|" << val << "|" << std::endl;
+
+	return false;
+}
+
+void gpio::set_value(bool state)
+{
+
+	if (state)
+		value_file << "1" << std::endl;
+	else
+		value_file << "0" << std::endl;
+}
+
+static void prepare_fpga_for_configuration(gpio &prog, gpio &)//init)
+{
+
+	prog.set_value(true);
+	prog.set_value(false);
+	prog.set_value(true);
+
+#if 0
+	bool ready_to_program(false);
+	unsigned int count(0);
+	do {
+		ready_to_program = init.get_value();
+		count++;
+
+		sleep(1);
+	} while (count < 10 && !ready_to_program);
+
+	if (count == 10) {
+		std::cout << "FPGA not ready for programming." << std::endl;
+		exit(-1);
+	}
+#endif
+}
+
+spidev::spidev(std::string fname)
+{
+	int ret;
+	int mode = 0;
+	int speed = 12000000;
+	int bits = 8;
+
+	fd = open(fname.c_str(), O_RDWR);
+
+	ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
+	ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
+	ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
+}
+	
+
+spidev::~spidev()
+{
+	close(fd);
+}
+
+void spidev::send(char *buf, char *rbuf, unsigned int nbytes)
+{
+	int ret;
+
+	struct spi_ioc_transfer tr;
+	tr.tx_buf = (unsigned long) buf;
+	tr.rx_buf = (unsigned long) rbuf;
+	tr.len = nbytes;
+	tr.delay_usecs = 0;
+	tr.speed_hz = 48000000;
+	tr.bits_per_word = 8;
+
+	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);	
+
+}
+
+static void send_file_to_fpga(const std::string &file_name, gpio &error, gpio &done)
+{
+	std::ifstream bitstream;
+
+	std::cout << "File name - " << file_name.c_str() << std::endl;
+
+	bitstream.open(file_name.c_str(), std::ios::binary);
+	if (!bitstream.is_open())
+		std::cout << "File " << file_name << " not opened succesfully." << std::endl;
+
+	spidev spi("/dev/spidev1.0");
+	char buf[BUF_SIZE];
+	char rbuf[BUF_SIZE];
+
+	do {
+		bitstream.read(buf, BUF_SIZE);
+		spi.send(buf, rbuf, bitstream.gcount());
+
+		if (error.get_value())
+			std::cout << "INIT_B went high, error occured." << std::endl;
+
+		if (!done.get_value())
+			std::cout << "Configuration complete." << std::endl;
+
+	} while (bitstream.gcount() == BUF_SIZE);
+}
+
+/*
+int main(int argc, char *argv[])
+{
+
+	gpio gpio_prog_b(PROG_B, OUT);
+	gpio gpio_init_b(INIT_B, IN);
+	gpio gpio_done  (DONE,   IN);
+
+	if (argc == 2)
+		bit_file = argv[1];
+
+	std::cout << "FPGA config file: " << bit_file << std::endl;
+
+	prepare_fpga_for_configuration(gpio_prog_b, gpio_init_b);
+
+	std::cout << "Done = " << gpio_done.get_value() << std::endl;
+
+	send_file_to_fpga(bit_file, gpio_init_b, gpio_done);
+}
+*/
+
+#include <uhd/usrp/usrp1e.hpp>
+void uhd::usrp::usrp1e::load_fpga(const std::string &bin_file){
+	gpio gpio_prog_b(PROG_B, OUT);
+	gpio gpio_init_b(INIT_B, IN);
+	gpio gpio_done  (DONE,   IN);
+
+	std::cout << "FPGA config file: " << bin_file << std::endl;
+
+	prepare_fpga_for_configuration(gpio_prog_b, gpio_init_b);
+
+	std::cout << "Done = " << gpio_done.get_value() << std::endl;
+
+	send_file_to_fpga(bin_file, gpio_init_b, gpio_done);
+}
diff --git a/host/lib/usrp/usrp1e/usrp1e_impl.cpp b/host/lib/usrp/usrp1e/usrp1e_impl.cpp
new file mode 100644
index 000000000..93265ab17
--- /dev/null
+++ b/host/lib/usrp/usrp1e/usrp1e_impl.cpp
@@ -0,0 +1,69 @@
+//
+// 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 <unistd.h>
+#include <boost/format.hpp>
+#include "usrp1e_impl.hpp"
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+/***********************************************************************
+ * Helper Functions
+ **********************************************************************/
+static bool file_exists(const std::string &file_path){
+    return access(file_path.c_str(), F_OK) == 0;
+}
+
+/***********************************************************************
+ * Discovery
+ **********************************************************************/
+device_addrs_t usrp1e::discover(const device_addr_t &device_addr){
+    device_addrs_t usrp1e_addrs;
+
+    //if a node was provided, use it and only it
+    if (device_addr.has_key("node")){
+        if (not file_exists(device_addr["node"])) return usrp1e_addrs;
+        device_addr_t new_addr;
+        new_addr["name"] = "USRP1E";
+        new_addr["type"] = "usrp1e";
+        new_addr["node"] = device_addr["node"];
+        usrp1e_addrs.push_back(new_addr);
+    }
+
+    //otherwise look for a few nodes at small indexes
+    else{
+        for(size_t i = 0; i < 5; i++){
+            std::string node = str(boost::format("/dev/usrp1_e%d") % i);
+            if (not file_exists(node)) continue;
+            device_addr_t new_addr;
+            new_addr["name"] = "USRP1E";
+            new_addr["type"] = "usrp1e";
+            new_addr["node"] = node;
+            usrp1e_addrs.push_back(new_addr);
+        }
+    }
+
+    return usrp1e_addrs;
+}
+
+/***********************************************************************
+ * Make
+ **********************************************************************/
+device::sptr usrp1e::make(const device_addr_t &){
+    throw std::runtime_error("not implemented yet");
+}
diff --git a/host/lib/shared_iovec.cpp b/host/lib/usrp/usrp1e/usrp1e_impl.hpp
index 60062fbf0..3f5f89ec6 100644
--- a/host/lib/shared_iovec.cpp
+++ b/host/lib/usrp/usrp1e/usrp1e_impl.hpp
@@ -15,14 +15,9 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include <uhd/shared_iovec.hpp>
+#include <uhd/usrp/usrp1e.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_;
-}
+#ifndef INCLUDED_USRP1E_IMPL_HPP
+#define INCLUDED_USRP1E_IMPL_HPP
 
-uhd::shared_iovec::~shared_iovec(void){
-    /* NOP */
-}
+#endif /* INCLUDED_USRP1E_IMPL_HPP */
diff --git a/host/lib/usrp/usrp1e/usrp1e_none.cpp b/host/lib/usrp/usrp1e/usrp1e_none.cpp
new file mode 100644
index 000000000..ac0b12a75
--- /dev/null
+++ b/host/lib/usrp/usrp1e/usrp1e_none.cpp
@@ -0,0 +1,38 @@
+//
+// 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/usrp1e.hpp>
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+/*!
+ * This file defines the usrp1e discover and make functions
+ * when the required kernel module headers are not present.
+ */
+
+device_addrs_t usrp1e::discover(const device_addr_t &){
+    return device_addrs_t(); //return empty list
+}
+
+device::sptr usrp1e::make(const device_addr_t &){
+    throw std::runtime_error("this build has no usrp1e support");
+}
+
+void usrp1e::load_fpga(const std::string &){
+    throw std::runtime_error("this build has no usrp1e support");
+}
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
new file mode 100644
index 000000000..43334ddc6
--- /dev/null
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -0,0 +1,242 @@
+//
+// 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 <complex>
+#include <boost/shared_array.hpp>
+#include <boost/format.hpp>
+#include "usrp2_impl.hpp"
+
+using namespace uhd;
+using namespace uhd::usrp;
+
+/***********************************************************************
+ * Constants
+ **********************************************************************/
+typedef std::complex<float>   fc32_t;
+typedef std::complex<int16_t> sc16_t;
+
+static const float float_scale_factor = pow(2.0, 15);
+
+//max length with header, stream id, seconds, fractional seconds
+static const size_t max_vrt_header_words = 5;
+
+/***********************************************************************
+ * Helper Functions
+ **********************************************************************/
+static inline void host_floats_to_usrp2_shorts(
+    int16_t *usrp2_shorts,
+    const float *host_floats,
+    size_t num_samps
+){
+    for(size_t i = 0; i < num_samps; i++){
+        usrp2_shorts[i] = htons(int16_t(host_floats[i]*float_scale_factor));
+    }
+}
+
+static inline void usrp2_shorts_to_host_floats(
+    float *host_floats,
+    const int16_t *usrp2_shorts,
+    size_t num_samps
+){
+    for(size_t i = 0; i < num_samps; i++){
+        host_floats[i] = float(ntohs(usrp2_shorts[i])/float_scale_factor);
+    }
+}
+
+static inline void host_shorts_to_usrp2_shorts(
+    int16_t *usrp2_shorts,
+    const int16_t *host_shorts,
+    size_t num_samps
+){
+    for(size_t i = 0; i < num_samps; i++){
+        usrp2_shorts[i] = htons(host_shorts[i]);
+    }
+}
+
+static inline void usrp2_shorts_to_host_shorts(
+    int16_t *host_shorts,
+    const int16_t *usrp2_shorts,
+    size_t num_samps
+){
+    for(size_t i = 0; i < num_samps; i++){
+        host_shorts[i] = ntohs(usrp2_shorts[i]);
+    }
+}
+
+/***********************************************************************
+ * Send Raw Data
+ **********************************************************************/
+size_t usrp2_impl::send_raw(
+    const boost::asio::const_buffer &buff,
+    const uhd::metadata_t &metadata
+){
+    std::vector<boost::asio::const_buffer> buffs(2);
+    uint32_t vrt_hdr[max_vrt_header_words];
+    uint32_t vrt_hdr_flags = 0;
+    size_t num_vrt_hdr_words = 1;
+
+    //load the vrt header and flags
+    if(metadata.has_stream_id){
+        vrt_hdr_flags |= (0x1 << 28); //IF Data packet with Stream Identifier
+        vrt_hdr[num_vrt_hdr_words++] = htonl(metadata.stream_id);
+    }
+    if(metadata.has_time_spec){
+        vrt_hdr_flags |= (0x3 << 22) | (0x1 << 20); //TSI: Other, TSF: Sample Count Timestamp
+        vrt_hdr[num_vrt_hdr_words++] = htonl(metadata.time_spec.secs);
+        vrt_hdr[num_vrt_hdr_words++] = htonl(metadata.time_spec.ticks);
+        vrt_hdr[num_vrt_hdr_words++] = 0; //unused part of fractional seconds
+    }
+    vrt_hdr_flags |= (metadata.start_of_burst)? (0x1 << 25) : 0;
+    vrt_hdr_flags |= (metadata.end_of_burst)?   (0x1 << 24) : 0;
+
+    //fill in complete header word
+    vrt_hdr[0] = htonl(vrt_hdr_flags |
+        ((_stream_id_to_packet_seq[metadata.stream_id]++ & 0xf) << 16) |
+        ((boost::asio::buffer_size(buff)/sizeof(uint32_t)) & 0xffff)
+    );
+
+    //load the buffer vector
+    size_t vrt_hdr_size = num_vrt_hdr_words*sizeof(uint32_t);
+    buffs[0] = boost::asio::buffer(&vrt_hdr, vrt_hdr_size);
+    buffs[1] = buff;
+
+    //send and return number of samples
+    return (_data_transport->send(buffs) - vrt_hdr_size)/sizeof(sc16_t);
+}
+
+/***********************************************************************
+ * Receive Raw Data
+ **********************************************************************/
+size_t usrp2_impl::recv_raw(
+    const boost::asio::mutable_buffer &buff,
+    uhd::metadata_t &metadata
+){
+    //load the buffer vector
+    std::vector<boost::asio::mutable_buffer> buffs(2);
+    uint32_t vrt_hdr[max_vrt_header_words];
+    buffs[0] = boost::asio::buffer(vrt_hdr, max_vrt_header_words);
+    buffs[1] = buff;
+
+    //receive into the buffers
+    size_t bytes_recvd = _data_transport->recv(buffs);
+
+    //failure case
+    if (bytes_recvd < max_vrt_header_words*sizeof(uint32_t)) return 0;
+
+    //unpack the vrt header
+    metadata = uhd::metadata_t();
+    uint32_t vrt_header = ntohl(vrt_hdr[0]);
+    metadata.has_stream_id = true;
+    metadata.stream_id = ntohl(vrt_hdr[1]);
+    metadata.has_time_spec = true;
+    metadata.time_spec.secs = ntohl(vrt_hdr[2]);
+    metadata.time_spec.ticks = ntohl(vrt_hdr[3]);
+
+    //return the number of samples received
+    size_t num_words = vrt_header & 0xffff;
+    return (num_words*sizeof(uint32_t))/sizeof(sc16_t);
+}
+
+/***********************************************************************
+ * Send Data
+ **********************************************************************/
+size_t usrp2_impl::send(
+    const boost::asio::const_buffer &buff,
+    const uhd::metadata_t &metadata,
+    const std::string &type
+){
+    if (type == "fc32"){
+        size_t num_samps = boost::asio::buffer_size(buff)/sizeof(fc32_t);
+        boost::shared_array<sc16_t> raw_mem(new sc16_t[num_samps]);
+        boost::asio::mutable_buffer raw_buff(raw_mem.get(), num_samps*sizeof(sc16_t));
+
+        host_floats_to_usrp2_shorts(
+            boost::asio::buffer_cast<int16_t*>(raw_buff),
+            boost::asio::buffer_cast<const float*>(buff),
+            num_samps*2 //double for complex
+        );
+
+        return send_raw(raw_buff, metadata);
+    }
+
+    if (type == "sc16"){
+        #ifdef HAVE_BIG_ENDIAN
+        return send_raw(buff, metadata);
+        #else
+        size_t num_samps = boost::asio::buffer_size(buff)/sizeof(sc16_t);
+        boost::shared_array<sc16_t> raw_mem(new sc16_t[num_samps]);
+        boost::asio::mutable_buffer raw_buff(raw_mem.get(), num_samps*sizeof(sc16_t));
+
+        host_shorts_to_usrp2_shorts(
+            boost::asio::buffer_cast<int16_t*>(raw_buff),
+            boost::asio::buffer_cast<const int16_t*>(buff),
+            num_samps*2 //double for complex
+        );
+
+        return send_raw(raw_buff, metadata);
+        #endif
+    }
+
+    throw std::runtime_error(str(boost::format("usrp2 send: cannot handle type \"%s\"") % type));
+}
+
+/***********************************************************************
+ * Receive Data
+ **********************************************************************/
+size_t usrp2_impl::recv(
+    const boost::asio::mutable_buffer &buff,
+    uhd::metadata_t &metadata,
+    const std::string &type
+){
+    if (type == "fc32"){
+        size_t num_samps = boost::asio::buffer_size(buff)/sizeof(fc32_t);
+        boost::shared_array<sc16_t> raw_mem(new sc16_t[num_samps]);
+        boost::asio::mutable_buffer raw_buff(raw_mem.get(), num_samps*sizeof(sc16_t));
+
+        num_samps = recv_raw(raw_buff, metadata);
+
+        usrp2_shorts_to_host_floats(
+            boost::asio::buffer_cast<float*>(buff),
+            boost::asio::buffer_cast<const int16_t*>(raw_buff),
+            num_samps*2 //double for complex
+        );
+
+        return num_samps;
+    }
+
+    if (type == "sc16"){
+        #ifdef HAVE_BIG_ENDIAN
+        return recv_raw(buff, metadata);
+        #else
+        size_t num_samps = boost::asio::buffer_size(buff)/sizeof(sc16_t);
+        boost::shared_array<sc16_t> raw_mem(new sc16_t[num_samps]);
+        boost::asio::mutable_buffer raw_buff(raw_mem.get(), num_samps*sizeof(sc16_t));
+
+        num_samps = recv_raw(raw_buff, metadata);
+
+        usrp2_shorts_to_host_shorts(
+            boost::asio::buffer_cast<int16_t*>(buff),
+            boost::asio::buffer_cast<const int16_t*>(raw_buff),
+            num_samps*2 //double for complex
+        );
+
+        return num_samps;
+        #endif
+    }
+
+    throw std::runtime_error(str(boost::format("usrp2 recv: cannot handle type \"%s\"") % type));
+}
diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp
index 2b4e8fe39..5aa5d6e8d 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -33,32 +33,35 @@ uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){
     //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);
+    transport::udp::sptr udp_transport = \
+        transport::udp::make(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)));
+    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)){
+        usrp2_ctrl_data_t ctrl_data_in;
+        size_t len = udp_transport->recv(
+            boost::asio::buffer(&ctrl_data_in, sizeof(ctrl_data_in))
+        );
+        //std::cout << len << "\n";
+        if (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)){
+            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));
+                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["type"] = "usrp2";
                 new_addr["addr"] = ip_addr.to_string();
                 usrp2_addrs.push_back(new_addr);
                 break;
@@ -72,21 +75,17 @@ uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){
 /***********************************************************************
  * Make
  **********************************************************************/
+#define num2str(num) (boost::lexical_cast<std::string>(num))
+
 device::sptr usrp2::make(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)
-        )
+    transport::udp::sptr ctrl_transport = transport::udp::make(
+        device_addr["addr"], num2str(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)
-        )
+    transport::udp::sptr data_transport = transport::udp::make(
+        device_addr["addr"], num2str(USRP2_UDP_DATA_PORT)
     );
 
     //create the usrp2 implementation guts
@@ -99,8 +98,8 @@ device::sptr usrp2::make(const device_addr_t &device_addr){
  * Structors
  **********************************************************************/
 usrp2_impl::usrp2_impl(
-    uhd::transport::udp::sptr ctrl_transport,
-    uhd::transport::udp::sptr data_transport
+    transport::udp::sptr ctrl_transport,
+    transport::udp::sptr data_transport
 ){
     _ctrl_transport = ctrl_transport;
     _data_transport = data_transport;
@@ -121,9 +120,6 @@ usrp2_impl::usrp2_impl(
     //init the mboard
     mboard_init();
 
-    //init the tx and rx dboards
-    dboard_init();
-
     //init the ddc
     init_ddc_config();
 
@@ -132,6 +128,14 @@ usrp2_impl::usrp2_impl(
 
     //initialize the clock configuration
     init_clock_config();
+
+    //init the tx and rx dboards (do last)
+    dboard_init();
+
+    //send a small data packet so the usrp2 knows the udp source port
+    uint32_t zero_data = 0;
+    _data_transport->send(boost::asio::buffer(&zero_data, sizeof(zero_data)));
+
 }
 
 usrp2_impl::~usrp2_impl(void){
@@ -159,14 +163,16 @@ usrp2_ctrl_data_t usrp2_impl::ctrl_send_and_recv(const usrp2_ctrl_data_t &out_da
     //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)){
+        usrp2_ctrl_data_t in_data;
+        size_t len = _ctrl_transport->recv(
+            boost::asio::buffer(&in_data, sizeof(in_data))
+        );
+        if (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;
             }
@@ -202,14 +208,3 @@ void usrp2_impl::get(const wax::obj &key_, wax::obj &val){
 void usrp2_impl::set(const wax::obj &, const wax::obj &){
     throw std::runtime_error("Cannot set in usrp2 device");
 }
-
-/***********************************************************************
- * IO Interface
- **********************************************************************/
-void usrp2_impl::send_raw(const std::vector<boost::asio::const_buffer> &){
-    return;
-}
-
-uhd::shared_iovec usrp2_impl::recv_raw(void){
-    throw std::runtime_error("not implemented");
-}
diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp
index 2545efd58..9a4c42d42 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.hpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.hpp
@@ -98,10 +98,15 @@ public:
     double get_master_clock_freq(void);
 
     //the io interface
-    void send_raw(const std::vector<boost::asio::const_buffer> &);
-    uhd::shared_iovec recv_raw(void);
+    size_t send(const boost::asio::const_buffer &, const uhd::metadata_t &, const std::string &);
+    size_t recv(const boost::asio::mutable_buffer &, uhd::metadata_t &, const std::string &);
 
 private:
+    //the raw io interface (samples are in the usrp2 native format)
+    size_t send_raw(const boost::asio::const_buffer &, const uhd::metadata_t &);
+    size_t recv_raw(const boost::asio::mutable_buffer &, uhd::metadata_t &);
+    uhd::dict<uint32_t, size_t> _stream_id_to_packet_seq;
+
     //udp transports for control and data
     uhd::transport::udp::sptr _ctrl_transport;
     uhd::transport::udp::sptr _data_transport;