Merge branch 'master' into u1e_uhd

9 files changed, 465 insertions, 99 deletions

diff --git a/host/lib/CMakeLists.txt b/host/lib/CMakeLists.txt
index 5cf334678..edfefa127 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,21 @@ 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
+########################################################################
+LIST(APPEND libuhd_sources
+    usrp/usrp1e/usrp1e_none.cpp
+)
+
+########################################################################
+# 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/shared_iovec.cpp b/host/lib/usrp/usrp1e/usrp1e_none.cpp
index 60062fbf0..1c8cf9a5b 100644
--- a/host/lib/shared_iovec.cpp
+++ b/host/lib/usrp/usrp1e/usrp1e_none.cpp
@@ -15,14 +15,20 @@
 // 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_;
+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
 }
 
-uhd::shared_iovec::~shared_iovec(void){
-    /* NOP */
+device::sptr usrp1e::make(const device_addr_t &){
+    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..06876d241 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -33,32 +33,36 @@ 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["transport"] = "udp";
                 new_addr["addr"] = ip_addr.to_string();
                 usrp2_addrs.push_back(new_addr);
                 break;
@@ -72,21 +76,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 +99,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 +121,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 +129,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 +164,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 +209,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;