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

12 files changed, 843 insertions, 101 deletions

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;