Merge branch 'master' into usrp_e_next

9 files changed, 568 insertions, 767 deletions

diff --git a/host/lib/transport/CMakeLists.txt b/host/lib/transport/CMakeLists.txt
index 62c4f62b1..e9e82932c 100644
--- a/host/lib/transport/CMakeLists.txt
+++ b/host/lib/transport/CMakeLists.txt
@@ -31,11 +31,10 @@ IF(LIBUSB_FOUND)
         ${CMAKE_SOURCE_DIR}/lib/transport/libusb1_zero_copy.cpp
         ${CMAKE_SOURCE_DIR}/lib/transport/libusb1_base.cpp
         ${CMAKE_SOURCE_DIR}/lib/transport/libusb1_base.hpp
-        ${CMAKE_SOURCE_DIR}/lib/transport/libusb1_device_handle.cpp
     )
-    IF(WIN32) #include our custom stdint for libusb
-	INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/lib/transport/include)
-    ENDIF(WIN32)
+    IF(MSVC) #include our custom stdint for libusb
+        INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/lib/transport/msvc)
+    ENDIF(MSVC)
     SET(HAVE_USB_SUPPORT TRUE)
 ENDIF(LIBUSB_FOUND)
 
diff --git a/host/lib/transport/libusb1_base.cpp b/host/lib/transport/libusb1_base.cpp
index 1f816c6e2..49f524a32 100644
--- a/host/lib/transport/libusb1_base.cpp
+++ b/host/lib/transport/libusb1_base.cpp
@@ -16,111 +16,262 @@
 //
 
 #include "libusb1_base.hpp"
+#include <uhd/utils/thread_priority.hpp>
 #include <uhd/utils/assert.hpp>
+#include <uhd/types/dict.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/foreach.hpp>
+#include <boost/thread.hpp>
 #include <iostream>
 
+using namespace uhd;
 using namespace uhd::transport;
 
-/**********************************************************
- * Helper Methods
- **********************************************************/
+/***********************************************************************
+ * libusb session
+ **********************************************************************/
+class libusb_session_impl : public libusb::session{
+public:
+    libusb_session_impl(void){
+        UHD_ASSERT_THROW(libusb_init(&_context) == 0);
+        libusb_set_debug(_context, debug_level);
+        _thread_group.create_thread(boost::bind(&libusb_session_impl::run_event_loop, this));
+    }
 
-/**********************************************************
- * libusb namespace 
- **********************************************************/
-void libusb::init(libusb_context **ctx, int debug_level)
-{
-    if (libusb_init(ctx) < 0)
-        std::cerr << "error: libusb_init" << std::endl;
+    ~libusb_session_impl(void){
+        _running = false;
+        _thread_group.join_all();
+        libusb_exit(_context);
+    }
 
-    libusb_set_debug(*ctx, debug_level);
-}
+    libusb_context *get_context(void) const{
+        return _context;
+    }
 
-libusb_device_handle *libusb::open_device(libusb_context *ctx,
-                                          usb_device_handle::sptr handle)
-{
-    libusb_device_handle *dev_handle = NULL;
-    libusb_device **libusb_dev_list;
-    size_t dev_cnt = libusb_get_device_list(ctx, &libusb_dev_list);
-
-    //find and open the USB device 
-    for (size_t i = 0; i < dev_cnt; i++) {
-        libusb_device *dev = libusb_dev_list[i];
-
-        if (compare_device(dev, handle)) {
-            libusb_open(dev, &dev_handle);
-            libusb_unref_device(dev);
-            break;
+private:
+    libusb_context *_context;
+    boost::thread_group _thread_group;
+    bool _running;
+
+    void run_event_loop(void){
+        set_thread_priority_safe();
+        _running = true;
+        timeval tv;
+        while(_running){
+            tv.tv_sec = 0;
+            tv.tv_usec = 100000; //100ms
+            libusb_handle_events_timeout(this->get_context(), &tv);
         }
-            
-        libusb_unref_device(dev);
     }
+};
+
+libusb::session::sptr libusb::session::get_global_session(void){
+    static boost::weak_ptr<session> global_session;
+
+    //not expired -> get existing session
+    if (not global_session.expired()) return global_session.lock();
 
-    return dev_handle;
+    //create a new global session
+    sptr new_global_session(new libusb_session_impl());
+    global_session = new_global_session;
+    return new_global_session;
 }
 
-//note: changed order of checks so it only tries to get_serial and get_device_address if vid and pid match
-//doing this so it doesn't try to open the device if it's not ours
-bool libusb::compare_device(libusb_device *dev,
-                            usb_device_handle::sptr handle)
-{
-    std::string serial         = handle->get_serial();
-    boost::uint16_t vendor_id  = handle->get_vendor_id();
-    boost::uint16_t product_id = handle->get_product_id();
-    boost::uint16_t device_addr = handle->get_device_addr();
-
-    libusb_device_descriptor libusb_desc;
-    if (libusb_get_device_descriptor(dev, &libusb_desc) < 0)
-        return false;
-    if (vendor_id != libusb_desc.idVendor)
-        return false;
-    if (product_id != libusb_desc.idProduct)
-        return false; 
-    if (serial != get_serial(dev))
-        return false;
-    if (device_addr != libusb_get_device_address(dev))
-        return false;
-
-    return true;
+/***********************************************************************
+ * libusb device
+ **********************************************************************/
+class libusb_device_impl : public libusb::device{
+public:
+    libusb_device_impl(libusb_device *dev){
+        _session = libusb::session::get_global_session();
+        _dev = dev;
+    }
+
+    ~libusb_device_impl(void){
+        libusb_unref_device(this->get());
+    }
+
+    libusb_device *get(void) const{
+        return _dev;
+    }
+
+private:
+    libusb::session::sptr _session; //always keep a reference to session
+    libusb_device *_dev;
+};
+
+/***********************************************************************
+ * libusb device list
+ **********************************************************************/
+class libusb_device_list_impl : public libusb::device_list{
+public:
+    libusb_device_list_impl(void){
+        libusb::session::sptr sess = libusb::session::get_global_session();
+
+        //allocate a new list of devices
+        libusb_device** dev_list;
+        ssize_t ret = libusb_get_device_list(sess->get_context(), &dev_list);
+        if (ret < 0) throw std::runtime_error("cannot enumerate usb devices");
+
+        //fill the vector of device references
+        for (size_t i = 0; i < size_t(ret); i++) _devs.push_back(
+            libusb::device::sptr(new libusb_device_impl(dev_list[i]))
+        );
+
+        //free the device list but dont unref (done in ~device)
+        libusb_free_device_list(dev_list, false/*dont unref*/);
+    }
+
+    size_t size(void) const{
+        return _devs.size();
+    }
+
+    libusb::device::sptr at(size_t i) const{
+        return _devs.at(i);
+    }
+
+private:
+    std::vector<libusb::device::sptr> _devs;
+};
+
+libusb::device_list::sptr libusb::device_list::make(void){
+    return sptr(new libusb_device_list_impl());
 }
 
+/***********************************************************************
+ * libusb device descriptor
+ **********************************************************************/
+class libusb_device_descriptor_impl : public libusb::device_descriptor{
+public:
+    libusb_device_descriptor_impl(libusb::device::sptr dev){
+        _dev = dev;
+        UHD_ASSERT_THROW(libusb_get_device_descriptor(_dev->get(), &_desc) == 0);
+    }
 
-bool libusb::open_interface(libusb_device_handle *dev_handle,
-                            int interface)
-{
-    int ret = libusb_claim_interface(dev_handle, interface);
-    if (ret < 0) {
-        std::cerr << "error: libusb_claim_interface() " << ret << std::endl;
-        return false;
+    const libusb_device_descriptor &get(void) const{
+        return _desc;
     }
-    else {
-        return true;
+
+    std::string get_ascii_serial(void) const{
+        if (this->get().iSerialNumber == 0) return "";
+
+        libusb::device_handle::sptr handle(
+            libusb::device_handle::get_cached_handle(_dev)
+        );
+
+        unsigned char buff[512];
+        ssize_t ret = libusb_get_string_descriptor_ascii(
+            handle->get(), this->get().iSerialNumber, buff, sizeof(buff)
+        );
+        if (ret < 0) return ""; //on error, just return empty string
+
+        return std::string((char *)buff, ret);
     }
+
+private:
+    libusb::device::sptr _dev; //always keep a reference to device
+    libusb_device_descriptor _desc;
+};
+
+libusb::device_descriptor::sptr libusb::device_descriptor::make(device::sptr dev){
+    return sptr(new libusb_device_descriptor_impl(dev));
 }
 
+/***********************************************************************
+ * libusb device handle
+ **********************************************************************/
+class libusb_device_handle_impl : public libusb::device_handle{
+public:
+    libusb_device_handle_impl(libusb::device::sptr dev){
+        _dev = dev;
+        UHD_ASSERT_THROW(libusb_open(_dev->get(), &_handle) == 0);
+    }
+
+    ~libusb_device_handle_impl(void){
+        //release all claimed interfaces
+        for (size_t i = 0; i < _claimed.size(); i++){
+            libusb_release_interface(this->get(), _claimed[i]);
+        }
+        libusb_close(_handle);
+    }
+
+    libusb_device_handle *get(void) const{
+        return _handle;
+    }
 
-std::string libusb::get_serial(libusb_device *dev)
-{
-    unsigned char buff[32];
+    void claim_interface(int interface){
+        UHD_ASSERT_THROW(libusb_claim_interface(this->get(), interface) == 0);
+        _claimed.push_back(interface);
+    }
 
-    libusb_device_descriptor desc;
-    if (libusb_get_device_descriptor(dev, &desc) < 0)
-        return "";
+private:
+    libusb::device::sptr _dev; //always keep a reference to device
+    libusb_device_handle *_handle;
+    std::vector<int> _claimed;
+};
 
-    if (desc.iSerialNumber == 0)
-        return "";
+libusb::device_handle::sptr libusb::device_handle::get_cached_handle(device::sptr dev){
+    static uhd::dict<libusb_device *, boost::weak_ptr<device_handle> > handles;
 
-    //open the device because we have to
-    libusb_device_handle *dev_handle;
-    if (libusb_open(dev, &dev_handle) < 0)
-        return "";
+    //not expired -> get existing session
+    if (handles.has_key(dev->get()) and not handles[dev->get()].expired()){
+        return handles[dev->get()].lock();
+    }
 
-    if (libusb_get_string_descriptor_ascii(dev_handle, desc.iSerialNumber,
-                                           buff, sizeof(buff)) < 0) {
-        return "";
+    //create a new global session
+    sptr new_handle(new libusb_device_handle_impl(dev));
+    handles[dev->get()] = new_handle;
+    return new_handle;
+}
+
+/***********************************************************************
+ * libusb special handle
+ **********************************************************************/
+class libusb_special_handle_impl : public libusb::special_handle{
+public:
+    libusb_special_handle_impl(libusb::device::sptr dev){
+        _dev = dev;
     }
 
-    libusb_close(dev_handle);
+    libusb::device::sptr get_device(void) const{
+        return _dev;
+    }
+
+    std::string get_serial(void) const{
+        return libusb::device_descriptor::make(this->get_device())->get_ascii_serial();
+    }
+
+    boost::uint16_t get_vendor_id(void) const{
+        return libusb::device_descriptor::make(this->get_device())->get().idVendor;
+    }
+
+    boost::uint16_t get_product_id(void) const{
+        return libusb::device_descriptor::make(this->get_device())->get().idProduct;
+    }
+
+private:
+    libusb::device::sptr _dev; //always keep a reference to device
+};
+
+libusb::special_handle::sptr libusb::special_handle::make(device::sptr dev){
+    return sptr(new libusb_special_handle_impl(dev));
+}
+
+/***********************************************************************
+ * list device handles implementations
+ **********************************************************************/
+std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(
+    boost::uint16_t vid, boost::uint16_t pid
+){
+    std::vector<usb_device_handle::sptr> handles;
+
+    libusb::device_list::sptr dev_list = libusb::device_list::make();
+    for (size_t i = 0; i < dev_list->size(); i++){
+        usb_device_handle::sptr handle = libusb::special_handle::make(dev_list->at(i));
+        if (handle->get_vendor_id() == vid and handle->get_product_id() == pid){
+            handles.push_back(handle);
+        }
+    }
 
-    return (char*) buff;
+    return handles;
 }
diff --git a/host/lib/transport/libusb1_base.hpp b/host/lib/transport/libusb1_base.hpp
index 484bcf3d9..04c1d6574 100644
--- a/host/lib/transport/libusb1_base.hpp
+++ b/host/lib/transport/libusb1_base.hpp
@@ -19,74 +19,129 @@
 #define INCLUDED_LIBUHD_TRANSPORT_LIBUSB_HPP
 
 #include <uhd/config.hpp>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
 #include <uhd/transport/usb_device_handle.hpp>
-#include <libusb-1.0/libusb.h>
+#include <libusb.h>
 
+/***********************************************************************
+ * Libusb object oriented smart pointer wrappers:
+ * The following wrappers provide allocation and automatic deallocation
+ * for various libusb data types and handles. The construction routines
+ * also store tables of already allocated structures to avoid multiple
+ * occurrences of opened handles (for example).
+ **********************************************************************/
 namespace uhd { namespace transport {
 
 namespace libusb {
-    /*
-     * Initialize libusb and set debug level
-     * Takes a pointer to context pointer because that's
-     * how libusb rolls. Debug levels.
-     *     
-     *   Level 0: no messages ever printed by the library (default)
-     *   Level 1: error messages are printed to stderr
-     *   Level 2: warning and error messages are printed to stderr
-     *   Level 3: informational messages are printed to stdout, warning
-     *            and error messages are printed to stderr
-     *
-     * \param ctx pointer to context pointer
-     * \param debug_level
+
+    /*!
+     * This session class holds a global libusb context for this process.
+     * The get global session call will create a new context if none exists.
+     * When all references to session are destroyed, the context will be freed.
      */
-    void init(libusb_context **ctx, int debug_level);
-
-    /*
-     * Open the device specified by a generic handle
-     * Find the libusb_device cooresponding to the generic handle
-     * and open it for I/O, which returns a libusb_device_handle
-     * ready for an interface
-     * \param ctx the libusb context used for init
-     * \return a libusb_device_handle ready for action 
+    class session : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<session> sptr;
+
+        /*!
+         *   Level 0: no messages ever printed by the library (default)
+         *   Level 1: error messages are printed to stderr
+         *   Level 2: warning and error messages are printed to stderr
+         *   Level 3: informational messages are printed to stdout, warning
+         *            and error messages are printed to stderr
+         */
+        static const int debug_level = 0;
+
+        //! get a shared pointer to the global session
+        static sptr get_global_session(void);
+
+        //! get the underlying libusb context pointer
+        virtual libusb_context *get_context(void) const = 0;
+    };
+
+    /*!
+     * Holds a device pointer with a reference to the session.
      */
-    libusb_device_handle *open_device(libusb_context *ctx,
-                                      usb_device_handle::sptr handle);
-
-    /*
-     * Compare a libusb device with a generic handle 
-     * Check the descriptors and open the device to check the
-     * serial number string. Compare values against the given
-     * handle. The libusb context is already implied in the
-     * libusb_device.
-     * \param dev a libusb_device pointer
-     * \param handle a generic handle specifier
-     * \return true if handle and device match, false otherwise
+    class device : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<device> sptr;
+
+        //! get the underlying device pointer
+        virtual libusb_device *get(void) const = 0;
+    };
+
+    /*!
+     * This device list class holds a device list that will be
+     * automatically freed when the last reference is destroyed.
      */
-    bool compare_device(libusb_device *dev, usb_device_handle::sptr handle);
-
-    /*
-     * Open an interface to the device
-     * This is a logical operation for operating system housekeeping as
-     * nothing is sent over the bus. The interface much correspond
-     * to the USB device descriptors.
-     * \param dev_handle libusb handle to an opened device
-     * \param interface integer of the interface to use
-     * \return true on success, false on error
+    class device_list : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<device_list> sptr;
+
+        //! make a new device list
+        static sptr make(void);
+
+        //! the number of devices in this list
+        virtual size_t size() const = 0;
+
+        //! get the device pointer at a particular index
+        virtual device::sptr at(size_t index) const = 0;
+    };
+
+    /*!
+     * Holds a device descriptor and a reference to the device.
      */
-    bool open_interface(libusb_device_handle *dev_handle, int interface);
-
-    /*
-     * Get serial number 
-     * The standard USB device descriptor contains an index to an
-     * actual serial number string descriptor. The index is readily
-     * readble, but the string descriptor requires probing the device.
-     * Because this call attempts to open the device, it may not
-     * succeed because not all USB devices are readily opened.
-     * The default language is used for the request (English).
-     * \param dev a libusb_device pointer
-     * \return string serial number or 0 on error or unavailablity
+    class device_descriptor : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<device_descriptor> sptr;
+
+        //! make a new descriptor from a device reference
+        static sptr make(device::sptr);
+
+        //! get the underlying device descriptor
+        virtual const libusb_device_descriptor &get(void) const = 0;
+
+        virtual std::string get_ascii_serial(void) const = 0;
+    };
+
+    /*!
+     * Holds a device handle and a reference to the device.
      */
-    std::string get_serial(libusb_device *dev);
+    class device_handle : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<device_handle> sptr;
+
+        //! get a cached handle or make a new one given the device
+        static sptr get_cached_handle(device::sptr);
+
+        //! get the underlying device handle
+        virtual libusb_device_handle *get(void) const = 0;
+
+        /*!
+         * Open USB interfaces for control using magic value
+         * IN interface:      2
+         * OUT interface:     1
+         * Control interface: 0
+         */
+        virtual void claim_interface(int) = 0;
+    };
+
+    /*!
+     * The special handle is our internal implementation of the
+     * usb device handle which is used publicly to identify a device.
+     */
+    class special_handle : public usb_device_handle {
+    public:
+        typedef boost::shared_ptr<special_handle> sptr;
+
+        //! make a new special handle from device
+        static sptr make(device::sptr);
+
+        //! get the underlying device reference
+        virtual device::sptr get_device(void) const = 0;
+    };
+
 }
 
 }} //namespace
diff --git a/host/lib/transport/libusb1_control.cpp b/host/lib/transport/libusb1_control.cpp
index 3531128b2..f903907d0 100644
--- a/host/lib/transport/libusb1_control.cpp
+++ b/host/lib/transport/libusb1_control.cpp
@@ -20,7 +20,6 @@
 
 using namespace uhd::transport;
 
-const int libusb_debug_level = 0;
 const int libusb_timeout = 0;
 
 /***********************************************************************
@@ -28,68 +27,38 @@ const int libusb_timeout = 0;
  **********************************************************************/
 class libusb_control_impl : public usb_control {
 public:
-    libusb_control_impl(usb_device_handle::sptr handle);
-    ~libusb_control_impl();
+    libusb_control_impl(libusb::device_handle::sptr handle):
+        _handle(handle)
+    {
+        _handle->claim_interface(0 /* control interface */);
+    }
 
-    size_t submit(boost::uint8_t request_type,
+    ssize_t submit(boost::uint8_t request_type,
                   boost::uint8_t request,
                   boost::uint16_t value,
                   boost::uint16_t index,
                   unsigned char *buff,
-                  boost::uint16_t length); 
+                  boost::uint16_t length
+    ){
+        return libusb_control_transfer(_handle->get(),
+                                       request_type,
+                                       request,
+                                       value,
+                                       index,
+                                       buff,
+                                       length,
+                                       libusb_timeout);
+    }
 
 private:
-    libusb_context       *_ctx;
-    libusb_device_handle *_dev_handle;
+    libusb::device_handle::sptr _handle;
 };
 
-
-libusb_control_impl::libusb_control_impl(usb_device_handle::sptr handle)
-{
-    libusb::init(&_ctx, libusb_debug_level);
-
-    // Find and open the libusb_device corresponding to the
-    // given handle and return the libusb_device_handle
-    // that can be used for I/O purposes.
-    _dev_handle = libusb::open_device(_ctx, handle);
-
-    // Open USB interfaces for control using magic value
-    // IN interface:      2
-    // OUT interface:     1
-    // Control interface: 0
-    libusb::open_interface(_dev_handle, 0);
-}
-
-
-libusb_control_impl::~libusb_control_impl()
-{
-    libusb_close(_dev_handle);
-    libusb_exit(_ctx);
-}
-
-
-size_t libusb_control_impl::submit(boost::uint8_t request_type,
-                                   boost::uint8_t request,
-                                   boost::uint16_t value,
-                                   boost::uint16_t index, 
-                                   unsigned char *buff,
-                                   boost::uint16_t length) 
-{
-    return libusb_control_transfer(_dev_handle,
-                                   request_type,
-                                   request,
-                                   value,
-                                   index,
-                                   buff, 
-                                   length, 
-                                   libusb_timeout);
-}
-
-
 /***********************************************************************
  * USB control public make functions
  **********************************************************************/
-usb_control::sptr usb_control::make(usb_device_handle::sptr handle)
-{
-    return sptr(new libusb_control_impl(handle));
+usb_control::sptr usb_control::make(usb_device_handle::sptr handle){
+    return sptr(new libusb_control_impl(libusb::device_handle::get_cached_handle(
+        boost::static_pointer_cast<libusb::special_handle>(handle)->get_device()
+    )));
 }
diff --git a/host/lib/transport/libusb1_device_handle.cpp b/host/lib/transport/libusb1_device_handle.cpp
deleted file mode 100644
index 7efddd410..000000000
--- a/host/lib/transport/libusb1_device_handle.cpp
+++ /dev/null
@@ -1,117 +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/>.
-//
-
-#include "libusb1_base.hpp"
-#include <uhd/utils/assert.hpp>
-#include <iostream>
-
-using namespace uhd::transport;
-
-const int libusb_debug_level = 0;
-
-/****************************************************************
- * libusb USB device handle implementation class
- ***************************************************************/
-class libusb1_device_handle_impl : public usb_device_handle {
-public:
-    libusb1_device_handle_impl(std::string serial,
-                               boost::uint16_t product_id,
-                               boost::uint16_t vendor_id,
-                               boost::uint16_t device_addr)
-      : _serial(serial), _product_id(product_id), 
-        _vendor_id(vendor_id), _device_addr(device_addr)
-    {
-        /* NOP */
-    }
-
-    ~libusb1_device_handle_impl()
-    {
-        /* NOP */
-    }
-
-    std::string get_serial() const
-    {
-        return _serial;
-    }
-
-    boost::uint16_t get_vendor_id() const
-    {
-        return _vendor_id;
-    }
-
-
-    boost::uint16_t get_product_id() const
-    {
-        return _product_id;
-    }
-
-    boost::uint16_t get_device_addr() const
-    {
-        return _device_addr;
-    }
-
-private:
-    std::string     _serial;
-    boost::uint16_t _product_id;
-    boost::uint16_t _vendor_id;
-    boost::uint16_t _device_addr;
-};
-
-
-usb_device_handle::sptr make_usb_device_handle(libusb_device *dev)
-{
-    libusb_device_descriptor desc;
-
-    if (libusb_get_device_descriptor(dev, &desc) < 0) {
-        UHD_ASSERT_THROW("USB: failed to get device descriptor");
-    }
-
-    std::string     serial      = libusb::get_serial(dev);
-    boost::uint16_t product_id  = desc.idProduct;
-    boost::uint16_t vendor_id   = desc.idVendor;
-    boost::uint16_t device_addr = libusb_get_device_address(dev);
-
-    return usb_device_handle::sptr(new libusb1_device_handle_impl(
-        serial,
-        product_id,
-        vendor_id,
-        device_addr));
-}
-
-std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(boost::uint16_t vid, boost::uint16_t pid)
-{
-    libusb_context *ctx = NULL;
-    libusb_device** libusb_device_list;
-    std::vector<usb_device_handle::sptr> device_handle_list;
-    libusb_device_descriptor desc;
-
-    libusb::init(&ctx, libusb_debug_level);
-
-    size_t dev_size = libusb_get_device_list(ctx, &libusb_device_list);
-    for (size_t i = 0; i < dev_size; i++) {
-        libusb_device *dev = libusb_device_list[i];
-        if(libusb_get_device_descriptor(dev, &desc) < 0) {
-          UHD_ASSERT_THROW("USB: failed to get device descriptor");
-        }
-        if(desc.idVendor == vid && desc.idProduct == pid) {
-          device_handle_list.push_back(make_usb_device_handle(dev));
-        }
-    }
-
-    libusb_exit(ctx);
-    return device_handle_list; 
-}
diff --git a/host/lib/transport/libusb1_zero_copy.cpp b/host/lib/transport/libusb1_zero_copy.cpp
index b3a160462..f9beb0b4c 100644
--- a/host/lib/transport/libusb1_zero_copy.cpp
+++ b/host/lib/transport/libusb1_zero_copy.cpp
@@ -17,16 +17,22 @@
 
 #include "libusb1_base.hpp"
 #include <uhd/transport/usb_zero_copy.hpp>
+#include <uhd/transport/bounded_buffer.hpp>
 #include <uhd/utils/assert.hpp>
-#include <boost/format.hpp>
+#include <boost/shared_array.hpp>
+#include <boost/foreach.hpp>
+#include <boost/thread.hpp>
+#include <vector>
 #include <iostream>
 #include <iomanip>
 
 using namespace uhd::transport;
 
-const int libusb_debug_level = 0;
 const int libusb_timeout = 0;
 
+static const size_t DEFAULT_NUM_XFERS = 16;     //num xfers
+static const size_t DEFAULT_XFER_SIZE = 32*512; //bytes
+
 /***********************************************************************
  * Helper functions
  ***********************************************************************/
@@ -53,56 +59,60 @@ void pp_transfer(libusb_transfer *lut)
  *   create a bidirectional interface. It is a zero copy implementation
  *   with respect to libusb, however, each send and recv requires a copy
  *   operation from kernel to userspace; this is due to the usbfs
- *   interface provided by the kernel. 
+ *   interface provided by the kernel.
  **********************************************************************/
 class usb_endpoint {
+public:
+    typedef boost::shared_ptr<usb_endpoint> sptr;
+
+    usb_endpoint(
+        libusb::device_handle::sptr handle,
+        int endpoint,
+        bool input,
+        size_t transfer_size,
+        size_t num_transfers
+    );
+
+    ~usb_endpoint(void);
+
+    // Exposed interface for submitting / retrieving transfer buffers
+
+    //! Submit a new transfer that was presumably just filled or emptied.
+    void submit(libusb_transfer *lut);
+
+    /*!
+     * Get an available transfer:
+     * For inputs, this is a just filled transfer.
+     * For outputs, this is a just emptied transfer.
+     * \param timeout_ms the timeout to wait for a lut
+     * \return the transfer pointer or NULL if timeout
+     */
+    libusb_transfer *get_lut_with_wait(size_t timeout_ms = 100);
+
+    //Callback use only
+    void callback_handle_transfer(libusb_transfer *lut);
+
 private:
-    libusb_device_handle *_dev_handle;
-    libusb_context *_ctx;
+    libusb::device_handle::sptr _handle;
     int  _endpoint;
     bool _input;
 
     size_t _transfer_size;
     size_t _num_transfers;
 
-    // Transfer state lists (transfers are free, pending, or completed)
-    std::list<libusb_transfer *>  _free_list;
-    std::list<libusb_transfer *>  _pending_list;
-    std::list<libusb_transfer *>  _completed_list;
-
-    // Calls for processing asynchronous I/O 
-    libusb_transfer *allocate_transfer(int buff_len);
-    bool cancel(libusb_transfer *lut);
-    bool cancel_all();
-    bool reap_pending_list();
-    bool reap_pending_list_timeout();
-    bool reap_completed_list();
-
-    // Transfer state manipulators 
-    void free_list_add(libusb_transfer *lut);
-    void pending_list_add(libusb_transfer *lut);
-    void completed_list_add(libusb_transfer *lut);
-    libusb_transfer *free_list_get();
-    libusb_transfer *completed_list_get();
-    bool pending_list_remove(libusb_transfer *lut);
-
-    // Debug use
-    void print_transfer_status(libusb_transfer *lut);
-
-public:
-    usb_endpoint(libusb_device_handle *dev_handle,
-                 libusb_context *ctx, int endpoint, bool input,
-                 size_t transfer_size, size_t num_transfers);
+    //! hold a bounded buffer of completed transfers
+    typedef bounded_buffer<libusb_transfer *> lut_buff_type;
+    lut_buff_type::sptr _completed_list;
 
-    ~usb_endpoint();
+    //! a list of all transfer structs we allocated
+    std::vector<libusb_transfer *>  _all_luts;
 
-    // Exposed interface for submitting / retrieving transfer buffers
-    bool submit(libusb_transfer *lut);
-    libusb_transfer *get_completed_transfer();
-    libusb_transfer *get_free_transfer();
+    //! a list of shared arrays for the transfer buffers
+    std::vector<boost::shared_array<boost::uint8_t> > _buffers;
 
-    //Callback use only
-    void callback_handle_transfer(libusb_transfer *lut);
+    // Calls for processing asynchronous I/O
+    libusb_transfer *allocate_transfer(int buff_len);
+    void print_transfer_status(libusb_transfer *lut);
 };
 
 
@@ -115,9 +125,8 @@ public:
  * it from the pending to completed status list.
  * \param lut pointer to libusb_transfer
  */
-static void callback(libusb_transfer *lut)
-{
-    usb_endpoint *endpoint = (usb_endpoint *) lut->user_data; 
+static void callback(libusb_transfer *lut){
+    usb_endpoint *endpoint = (usb_endpoint *) lut->user_data;
     endpoint->callback_handle_transfer(lut);
 }
 
@@ -126,14 +135,9 @@ static void callback(libusb_transfer *lut)
  * Accessor call to allow list access from callback space
  * \param pointer to libusb_transfer
  */
-void usb_endpoint::callback_handle_transfer(libusb_transfer *lut)
-{
-    if (!pending_list_remove(lut)) {
-        std::cerr << "USB: pending remove failed" << std::endl;
-        return;
-    }
-
-    completed_list_add(lut);    
+void usb_endpoint::callback_handle_transfer(libusb_transfer *lut){
+    boost::this_thread::disable_interruption di; //disable because the wait can throw
+    _completed_list->push_with_wait(lut);
 }
 
 
@@ -141,21 +145,30 @@ void usb_endpoint::callback_handle_transfer(libusb_transfer *lut)
  * Constructor
  * Allocate libusb transfers and mark as free.  For IN endpoints,
  * submit the transfers so that they're ready to return when
- * data is available. 
+ * data is available.
  */
-usb_endpoint::usb_endpoint(libusb_device_handle *dev_handle,
-                          libusb_context *ctx, int endpoint, bool input,
-                          size_t transfer_size, size_t num_transfers)
-    : _dev_handle(dev_handle),
-      _ctx(ctx), _endpoint(endpoint), _input(input),
-      _transfer_size(transfer_size), _num_transfers(num_transfers)
+usb_endpoint::usb_endpoint(
+    libusb::device_handle::sptr handle,
+    int endpoint,
+    bool input,
+    size_t transfer_size,
+    size_t num_transfers
+):
+    _handle(handle),
+    _endpoint(endpoint),
+    _input(input),
+    _transfer_size(transfer_size),
+    _num_transfers(num_transfers)
 {
-    unsigned int i;
-    for (i = 0; i < _num_transfers; i++) {
-        free_list_add(allocate_transfer(_transfer_size));
+    _completed_list = lut_buff_type::make(num_transfers);
+
+    for (size_t i = 0; i < _num_transfers; i++){
+        _all_luts.push_back(allocate_transfer(_transfer_size));
 
-        if (_input)
-            submit(free_list_get());
+        //input luts are immediately submitted to be filled
+        //output luts go into the completed list as free buffers
+        if (_input) this->submit(_all_luts.back());
+        else _completed_list->push_with_wait(_all_luts.back());
     }
 }
 
@@ -167,47 +180,44 @@ usb_endpoint::usb_endpoint(libusb_device_handle *dev_handle,
  * the transfers. Libusb will deallocate the data buffer held by
  * each transfer.
  */
-usb_endpoint::~usb_endpoint()
-{
-    cancel_all();
-
-    while (!_pending_list.empty()) {
-        if (!reap_pending_list())
-            std::cerr << "error: destructor failed to reap" << std::endl;
+usb_endpoint::~usb_endpoint(void){
+    //cancel all transfers
+    BOOST_FOREACH(libusb_transfer *lut, _all_luts){
+        libusb_cancel_transfer(lut);
     }
 
-    while (!_completed_list.empty()) {
-        if (!reap_completed_list())
-            std::cerr << "error: destructor failed to reap" << std::endl;
-    }
+    //collect canceled transfers (drain the queue)
+    while (this->get_lut_with_wait() != NULL){};
 
-    while (!_free_list.empty()) {
-        libusb_free_transfer(free_list_get());
+    //free all transfers
+    BOOST_FOREACH(libusb_transfer *lut, _all_luts){
+        libusb_free_transfer(lut);
     }
 }
 
 
 /*
- * Allocate a libusb transfer 
+ * Allocate a libusb transfer
  * The allocated transfer - and buffer it contains - is repeatedly
  * submitted, reaped, and reused and should not be freed until shutdown.
  * \param buff_len size of the individual buffer held by each transfer
  * \return pointer to an allocated libusb_transfer
  */
-libusb_transfer *usb_endpoint::allocate_transfer(int buff_len)
-{
+libusb_transfer *usb_endpoint::allocate_transfer(int buff_len){
     libusb_transfer *lut = libusb_alloc_transfer(0);
 
-    unsigned char *buff = new unsigned char[buff_len];
+    boost::shared_array<boost::uint8_t> buff(new boost::uint8_t[buff_len]);
+    _buffers.push_back(buff); //store a reference to this shared array
 
     unsigned int endpoint = ((_endpoint & 0x7f) | (_input ? 0x80 : 0));
+    libusb_transfer_cb_fn lut_callback = libusb_transfer_cb_fn(&callback);
 
     libusb_fill_bulk_transfer(lut,                // transfer
-                              _dev_handle,        // dev_handle
+                              _handle->get(),     // dev_handle
                               endpoint,           // endpoint
-                              buff,               // buffer
+                              buff.get(),         // buffer
                               buff_len,           // length
-       libusb_transfer_cb_fn(callback),           // callback
+                              lut_callback,       // callback
                               this,               // user_data
                               0);                 // timeout
     return lut;
@@ -218,97 +228,17 @@ libusb_transfer *usb_endpoint::allocate_transfer(int buff_len)
  * Asynchonous transfer submission
  * Submit a libusb transfer to libusb add pending status
  * \param lut pointer to libusb_transfer
- * \return true on success or false on error 
- */
-bool usb_endpoint::submit(libusb_transfer *lut)
-{
-    int retval;
-    if ((retval = libusb_submit_transfer(lut)) < 0) {
-        std::cerr << "error: libusb_submit_transfer: " << retval << std::endl;
-        return false;
-    }
-
-    pending_list_add(lut);
-    return true;
-}
-
-
-/*
- * Cancel a pending transfer 
- * Search the pending list for the transfer and cancel if found.
- * \param lut pointer to libusb_transfer to cancel
- * \return true on success or false if transfer is not found
- *
- * Note: success only indicates submission of cancelation request.
- * Sucessful cancelation is not known until the callback occurs.
- */
-bool usb_endpoint::cancel(libusb_transfer *lut)
-{
-    std::list<libusb_transfer*>::iterator iter;
-    for (iter = _pending_list.begin(); iter != _pending_list.end(); iter++) {
-        if (*iter == lut) { 
-            libusb_cancel_transfer(lut); 
-            return true;
-        }
-    }
-    return false;
-}
-
-
-/*
- * Cancel all pending transfers 
- * \return bool true if cancelation request is submitted
- *
- * Note: success only indicates submission of cancelation request.
- * Sucessful cancelation is not known until the callback occurs.
+ * \return true on success or false on error
  */
-bool usb_endpoint::cancel_all()
-{
-    std::list<libusb_transfer*>::iterator iter;
-
-    for (iter = _pending_list.begin(); iter != _pending_list.end(); iter++) {
-        if (libusb_cancel_transfer(*iter) < 0) {
-            std::cerr << "error: libusb_cancal_transfer() failed" << std::endl;
-            return false;
-        }
-    }
-
-    return true;
-}
-
-
-/*
- * Reap completed transfers
- * return true if at least one transfer was reaped, false otherwise. 
- * Check completed transfers for errors and mark as free. This is a
- * blocking call. 
- * \return bool true if a libusb transfer is reaped, false otherwise
- */
-bool usb_endpoint::reap_completed_list()
-{
-    libusb_transfer *lut;
-
-    if (_completed_list.empty()) {
-        if (!reap_pending_list_timeout())
-            return false;
-    }
-
-    while (!_completed_list.empty()) {
-        lut = completed_list_get();
-        print_transfer_status(lut);
-        free_list_add(lut);
-    }
-
-    return true;
+void usb_endpoint::submit(libusb_transfer *lut){
+    UHD_ASSERT_THROW(libusb_submit_transfer(lut) == 0);
 }
 
-
 /*
  * Print status errors of a completed transfer
  * \param lut pointer to an libusb_transfer
  */
-void usb_endpoint::print_transfer_status(libusb_transfer *lut)
-{
+void usb_endpoint::print_transfer_status(libusb_transfer *lut){
     switch (lut->status) {
     case LIBUSB_TRANSFER_COMPLETED:
         if (lut->actual_length < lut->length) {
@@ -344,200 +274,46 @@ void usb_endpoint::print_transfer_status(libusb_transfer *lut)
     }
 }
 
-
-/*
- * Reap pending transfers without timeout 
- * This is a blocking call. Reaping submitted transfers is
- * handled by libusb and the assigned callback function.
- * Block until at least one transfer is reaped.
- * \return true true if a transfer was reaped or false otherwise
- */
-bool usb_endpoint::reap_pending_list()
-{
-    int retval;
-
-    if ((retval = libusb_handle_events(_ctx)) < 0) {
-        std::cerr << "error: libusb_handle_events: " << retval << std::endl;
-        return false;
-    }
-
-    return true;
-}
-
-
-/*
- * Reap pending transfers with timeout 
- * This call blocks until a transfer is reaped or timeout.
- * Reaping submitted transfers is handled by libusb and the
- * assigned callback function. Block until at least one
- * transfer is reaped or timeout occurs.
- * \return true if a transfer was reaped or false otherwise
- */
-bool usb_endpoint::reap_pending_list_timeout()
-{
-    int retval;
-    timeval tv;
-
-    tv.tv_sec = 0;
-    tv.tv_usec = 100000; //100ms
-
-    size_t pending_list_size = _pending_list.size();
-
-    if ((retval = libusb_handle_events_timeout(_ctx, &tv)) < 0) {
-        std::cerr << "error: libusb_handle_events: " << retval << std::endl;
-        return false;
-    }
-
-    if (_pending_list.size() < pending_list_size) {
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-
-
-/*
- * Get a free transfer
- * The transfer has an empty data bufer for OUT requests 
- * \return pointer to a libusb_transfer
- */
-libusb_transfer *usb_endpoint::get_free_transfer()
-{
-    if (_free_list.empty()) {
-        if (!reap_completed_list())
-            return NULL; 
-    }
-
-    return free_list_get();
-}
-
-
-/*
- * Get a completed transfer 
- * The transfer has a full data buffer for IN requests
- * \return pointer to libusb_transfer
- */
-libusb_transfer *usb_endpoint::get_completed_transfer()
-{
-    if (_completed_list.empty()) {
-        if (!reap_pending_list_timeout())
-            return NULL; 
-    }
-
-    return completed_list_get();
-}
-
-/*
- * List operations 
- */
-void usb_endpoint::free_list_add(libusb_transfer *lut)
-{
-    _free_list.push_back(lut);
-}
-
-void usb_endpoint::pending_list_add(libusb_transfer *lut)
-{
-    _pending_list.push_back(lut);
-}
-
-void usb_endpoint::completed_list_add(libusb_transfer *lut)
-{
-    _completed_list.push_back(lut);
-}
-
-
-/*
- * Free and completed lists don't have ordered content 
- * Pop transfers from the front as needed
- */
-libusb_transfer *usb_endpoint::free_list_get()
-{
+libusb_transfer *usb_endpoint::get_lut_with_wait(size_t timeout_ms){
+    boost::this_thread::disable_interruption di; //disable because the wait can throw
     libusb_transfer *lut;
-
-    if (_free_list.size() == 0) {
-        return NULL; 
-    }
-    else { 
-        lut = _free_list.front();
-        _free_list.pop_front();
-        return lut;
-    }
+    if (_completed_list->pop_with_timed_wait(
+        lut, boost::posix_time::milliseconds(timeout_ms)
+    )) return lut;
+    return NULL;
 }
 
-
-/*
- * Free and completed lists don't have ordered content 
- * Pop transfers from the front as needed
- */
-libusb_transfer *usb_endpoint::completed_list_get()
-{
-    libusb_transfer *lut;
-
-    if (_completed_list.empty()) {
-        return NULL;
-    }
-    else { 
-        lut = _completed_list.front();
-        _completed_list.pop_front();
-        return lut;
-    }
-}
-
-
-/*
- * Search and remove transfer from pending list
- * Assuming that the callbacks occur in order, the front element
- * should yield the correct transfer. If not, then something else
- * is going on. If no transfers match, then something went wrong.
- */
-bool usb_endpoint::pending_list_remove(libusb_transfer *lut)
-{
-    std::list<libusb_transfer*>::iterator iter;
-    for (iter = _pending_list.begin(); iter != _pending_list.end(); iter++) {
-        if (*iter == lut) { 
-            _pending_list.erase(iter);
-            return true;
-        }
-    }
-    return false;
-}
-
-
 /***********************************************************************
- * Managed buffers 
+ * Managed buffers
  **********************************************************************/
 /*
  * Libusb managed receive buffer
  * Construct a recv buffer from a libusb transfer. The memory held by
  * the libusb transfer is exposed through the managed buffer interface.
  * Upon destruction, the transfer and buffer are resubmitted to the
- * endpoint for further use. 
+ * endpoint for further use.
  */
 class libusb_managed_recv_buffer_impl : public managed_recv_buffer {
 public:
     libusb_managed_recv_buffer_impl(libusb_transfer *lut,
-                                    usb_endpoint *endpoint)
+                                    usb_endpoint::sptr endpoint)
         : _buff(lut->buffer, lut->length)
     {
         _lut = lut;
         _endpoint = endpoint;
     }
 
-    ~libusb_managed_recv_buffer_impl()
-    {
-       if (!_endpoint->submit(_lut))
-           std::cerr << "USB: failed to submit IN transfer" << std::endl;
+    ~libusb_managed_recv_buffer_impl(void){
+        _endpoint->submit(_lut);
     }
 
 private:
-    const boost::asio::const_buffer &get() const
-    {
-        return _buff; 
+    const boost::asio::const_buffer &get(void) const{
+        return _buff;
     }
 
     libusb_transfer *_lut;
-    usb_endpoint *_endpoint;
+    usb_endpoint::sptr _endpoint;
     const boost::asio::const_buffer _buff;
 };
 
@@ -553,16 +329,14 @@ private:
 class libusb_managed_send_buffer_impl : public managed_send_buffer {
 public:
     libusb_managed_send_buffer_impl(libusb_transfer *lut,
-                                    usb_endpoint *endpoint,
-                                    size_t buff_size)
-        : _buff(lut->buffer, buff_size), _committed(false)
+                                    usb_endpoint::sptr endpoint)
+        : _buff(lut->buffer, lut->length), _committed(false)
     {
         _lut = lut;
         _endpoint = endpoint;
     }
 
-    ~libusb_managed_send_buffer_impl()
-    {
+    ~libusb_managed_send_buffer_impl(void){
         if (!_committed) {
             _lut->length = 0;
             _lut->actual_length = 0;
@@ -576,29 +350,30 @@ public:
             std::cerr << "UHD: send buffer already committed" << std::endl;
             return 0;
         }
-        
+
         UHD_ASSERT_THROW(num_bytes <= boost::asio::buffer_size(_buff));
 
         _lut->length = num_bytes;
         _lut->actual_length = 0;
 
-        if (_endpoint->submit(_lut)) {
+        try{
+            _endpoint->submit(_lut);
             _committed = true;
             return num_bytes;
         }
-        else {
-            return 0;
+        catch(const std::exception &e){
+            std::cerr << "Error in commit: " << e.what() << std::endl;
+            return -1;
         }
     }
 
 private:
-    const boost::asio::mutable_buffer &get() const
-    {
-        return _buff; 
+    const boost::asio::mutable_buffer &get(void) const{
+        return _buff;
     }
 
     libusb_transfer *_lut;
-    usb_endpoint *_endpoint;
+    usb_endpoint::sptr _endpoint;
     const boost::asio::mutable_buffer _buff;
     bool _committed;
 };
@@ -610,116 +385,89 @@ private:
 class libusb_zero_copy_impl : public usb_zero_copy
 {
 private:
-    usb_endpoint          *_rx_ep;
-    usb_endpoint          *_tx_ep;
-
-    // Maintain libusb values
-    libusb_context       *_rx_ctx;
-    libusb_context       *_tx_ctx;
-    libusb_device_handle *_rx_dev_handle;
-    libusb_device_handle *_tx_dev_handle;
-
-    size_t _recv_buff_size;
-    size_t _send_buff_size;
-    size_t _num_frames;
+    libusb::device_handle::sptr _handle;
+    size_t _recv_num_frames, _send_num_frames;
+    usb_endpoint::sptr _recv_ep, _send_ep;
 
 public:
     typedef boost::shared_ptr<libusb_zero_copy_impl> sptr;
 
-    libusb_zero_copy_impl(usb_device_handle::sptr handle,
-                          unsigned int rx_endpoint,
-                          unsigned int tx_endpoint,
-                          size_t recv_buff_size,
-                          size_t send_buff_size);
-    
-    ~libusb_zero_copy_impl();
+    libusb_zero_copy_impl(
+        libusb::device_handle::sptr handle,
+        unsigned int recv_endpoint, unsigned int send_endpoint,
+        size_t recv_xfer_size, size_t recv_num_xfers,
+        size_t send_xfer_size, size_t send_num_xfers
+    );
 
-    managed_recv_buffer::sptr get_recv_buff(void);
+    managed_recv_buffer::sptr get_recv_buff(size_t timeout_ms);
     managed_send_buffer::sptr get_send_buff(void);
 
-    size_t get_num_recv_frames(void) const { return _num_frames; }
-    size_t get_num_send_frames(void) const { return _num_frames; }
+    size_t get_num_recv_frames(void) const { return _recv_num_frames; }
+    size_t get_num_send_frames(void) const { return _send_num_frames; }
 };
 
 /*
  * Constructor
  * Initializes libusb, opens devices, and sets up interfaces for I/O.
- * Finally, creates endpoints for asynchronous I/O. 
+ * Finally, creates endpoints for asynchronous I/O.
  */
-libusb_zero_copy_impl::libusb_zero_copy_impl(usb_device_handle::sptr handle,
-                                             unsigned int rx_endpoint,
-                                             unsigned int tx_endpoint,
-                                             size_t buff_size,
-                                             size_t block_size)
- : _rx_ctx(NULL), _tx_ctx(NULL), _rx_dev_handle(NULL), _tx_dev_handle(NULL),
-   _recv_buff_size(block_size), _send_buff_size(block_size),
-   _num_frames(buff_size / block_size)
-{
-    // Initialize libusb with separate contexts to allow
-    // thread safe operation of transmit and receive 
-    libusb::init(&_rx_ctx, libusb_debug_level);
-    libusb::init(&_tx_ctx, libusb_debug_level);
-
-    UHD_ASSERT_THROW((_rx_ctx != NULL) && (_tx_ctx != NULL));
-
-    // Find and open the libusb_device corresponding to the
-    // given handle and return the libusb_device_handle
-    // that can be used for I/O purposes.
-    _rx_dev_handle = libusb::open_device(_rx_ctx, handle);
-    _tx_dev_handle = libusb::open_device(_tx_ctx, handle);
-
-    // Open USB interfaces for tx/rx using magic values.
-    // IN interface:      2
-    // OUT interface:     1
-    // Control interface: 0
-    libusb::open_interface(_rx_dev_handle, 2);
-    libusb::open_interface(_tx_dev_handle, 1);
-
-    _rx_ep = new usb_endpoint(_rx_dev_handle,  // libusb device_handle
-                              _rx_ctx,         // libusb context
-                              rx_endpoint,     // USB endpoint number
+libusb_zero_copy_impl::libusb_zero_copy_impl(
+    libusb::device_handle::sptr handle,
+    unsigned int recv_endpoint, unsigned int send_endpoint,
+    size_t recv_xfer_size, size_t recv_num_xfers,
+    size_t send_xfer_size, size_t send_num_xfers
+){
+    _handle = handle;
+
+    //if the sizes are left at 0 (automatic) -> use the defaults
+    if (recv_xfer_size == 0) recv_xfer_size = DEFAULT_XFER_SIZE;
+    if (recv_num_xfers == 0) recv_num_xfers = DEFAULT_NUM_XFERS;
+    if (send_xfer_size == 0) send_xfer_size = DEFAULT_XFER_SIZE;
+    if (send_num_xfers == 0) send_num_xfers = DEFAULT_NUM_XFERS;
+
+    //sanity check the transfer sizes
+    UHD_ASSERT_THROW(recv_xfer_size % 512 == 0);
+    UHD_ASSERT_THROW(send_xfer_size % 512 == 0);
+
+    //store the num xfers for the num frames count
+    _recv_num_frames = recv_num_xfers;
+    _send_num_frames = send_num_xfers;
+
+    _handle->claim_interface(2 /*in interface*/);
+    _handle->claim_interface(1 /*out interface*/);
+
+    _recv_ep = usb_endpoint::sptr(new usb_endpoint(
+                              _handle,         // libusb device_handle
+                              recv_endpoint,   // USB endpoint number
                               true,            // IN endpoint
-                              _recv_buff_size, // buffer size per transfer 
-                              _num_frames);    // number of libusb transfers
+                              recv_xfer_size,  // buffer size per transfer
+                              recv_num_xfers   // number of libusb transfers
+    ));
 
-    _tx_ep = new usb_endpoint(_tx_dev_handle,  // libusb device_handle
-                              _tx_ctx,         // libusb context
-                              tx_endpoint,     // USB endpoint number
+    _send_ep = usb_endpoint::sptr(new usb_endpoint(
+                              _handle,         // libusb device_handle
+                              send_endpoint,   // USB endpoint number
                               false,           // OUT endpoint
-                              _send_buff_size, // buffer size per transfer
-                              _num_frames);    // number of libusb transfers
-}
-
-
-libusb_zero_copy_impl::~libusb_zero_copy_impl()
-{
-    delete _rx_ep;
-    delete _tx_ep; 
-
-    libusb_close(_rx_dev_handle);
-    libusb_close(_tx_dev_handle);
-
-    libusb_exit(_rx_ctx);
-    libusb_exit(_tx_ctx);
+                              send_xfer_size,  // buffer size per transfer
+                              send_num_xfers   // number of libusb transfers
+    ));
 }
 
-
 /*
  * Construct a managed receive buffer from a completed libusb transfer
  * (happy with buffer full of data) obtained from the receive endpoint.
  * Return empty pointer if no transfer is available (timeout or error).
- * \return pointer to a managed receive buffer 
+ * \return pointer to a managed receive buffer
  */
-managed_recv_buffer::sptr libusb_zero_copy_impl::get_recv_buff()
-{
-    libusb_transfer *lut = _rx_ep->get_completed_transfer();
+managed_recv_buffer::sptr libusb_zero_copy_impl::get_recv_buff(size_t timeout_ms){
+    libusb_transfer *lut = _recv_ep->get_lut_with_wait(timeout_ms);
     if (lut == NULL) {
         return managed_recv_buffer::sptr();
     }
     else {
         return managed_recv_buffer::sptr(
             new libusb_managed_recv_buffer_impl(lut,
-                                                _rx_ep));
+                                                _recv_ep));
     }
 }
 
@@ -728,39 +476,36 @@ managed_recv_buffer::sptr libusb_zero_copy_impl::get_recv_buff()
  * Construct a managed send buffer from a free libusb transfer (with
  * empty buffer). Return empty pointer of no transfer is available
  * (timeout or error).
- * \return pointer to a managed send buffer 
+ * \return pointer to a managed send buffer
  */
-managed_send_buffer::sptr libusb_zero_copy_impl::get_send_buff()
-{
-    libusb_transfer *lut = _tx_ep->get_free_transfer();
+managed_send_buffer::sptr libusb_zero_copy_impl::get_send_buff(void){
+    libusb_transfer *lut = _send_ep->get_lut_with_wait(/* TODO timeout API */);
     if (lut == NULL) {
         return managed_send_buffer::sptr();
     }
     else {
         return managed_send_buffer::sptr(
             new libusb_managed_send_buffer_impl(lut,
-                                                _tx_ep,
-                                                _send_buff_size));
+                                                _send_ep));
     }
 }
 
-
 /***********************************************************************
  * USB zero_copy make functions
  **********************************************************************/
-usb_zero_copy::sptr usb_zero_copy::make(usb_device_handle::sptr handle,
-                                        unsigned int rx_endpoint,
-                                        unsigned int tx_endpoint,
-                                        size_t buff_size,
-                                        size_t block_size)
-
-{
-    return sptr(new libusb_zero_copy_impl(handle,
-                                          rx_endpoint,
-                                          tx_endpoint,
-                                          buff_size, 
-                                          block_size));
+usb_zero_copy::sptr usb_zero_copy::make(
+	usb_device_handle::sptr handle,
+    unsigned int recv_endpoint, unsigned int send_endpoint,
+	size_t recv_xfer_size, size_t recv_num_xfers,
+	size_t send_xfer_size, size_t send_num_xfers
+){
+    libusb::device_handle::sptr dev_handle(libusb::device_handle::get_cached_handle(
+        boost::static_pointer_cast<libusb::special_handle>(handle)->get_device()
+    ));
+    return sptr(new libusb_zero_copy_impl(
+		dev_handle,
+		recv_endpoint,  send_endpoint,
+		recv_xfer_size, recv_num_xfers,
+		send_xfer_size, send_num_xfers
+    ));
 }
-
-
-
diff --git a/host/lib/transport/include/stdint.h b/host/lib/transport/msvc/stdint.h
index b3eb61aae..b3eb61aae 100644
--- a/host/lib/transport/include/stdint.h
+++ b/host/lib/transport/msvc/stdint.h
diff --git a/host/lib/transport/udp_zero_copy_asio.cpp b/host/lib/transport/udp_zero_copy_asio.cpp
index ee989ee2b..0a6c9f2af 100644
--- a/host/lib/transport/udp_zero_copy_asio.cpp
+++ b/host/lib/transport/udp_zero_copy_asio.cpp
@@ -35,7 +35,6 @@ static const size_t MIN_RECV_SOCK_BUFF_SIZE = size_t(sizeof(boost::uint32_t) * 2
 //Perhaps this is due to the kernel scheduling,
 //but may change with host-based flow control.
 static const size_t MIN_SEND_SOCK_BUFF_SIZE = size_t(10e3);
-static const double RECV_TIMEOUT = 0.1; //100 ms
 
 /***********************************************************************
  * Zero Copy UDP implementation with ASIO:
@@ -110,11 +109,11 @@ private:
     boost::asio::io_service        _io_service;
     int                            _sock_fd;
 
-    ssize_t recv(const boost::asio::mutable_buffer &buff){
+    ssize_t recv(const boost::asio::mutable_buffer &buff, size_t timeout_ms){
         //setup timeval for timeout
         timeval tv;
         tv.tv_sec = 0;
-        tv.tv_usec = int(RECV_TIMEOUT*1e6);
+        tv.tv_usec = timeout_ms*1000;
 
         //setup rset for timeout
         fd_set rset;
diff --git a/host/lib/transport/zero_copy.cpp b/host/lib/transport/zero_copy.cpp
index 8a1cde694..1fcf846a0 100644
--- a/host/lib/transport/zero_copy.cpp
+++ b/host/lib/transport/zero_copy.cpp
@@ -68,12 +68,12 @@ phony_zero_copy_recv_if::~phony_zero_copy_recv_if(void){
     /* NOP */
 }
 
-managed_recv_buffer::sptr phony_zero_copy_recv_if::get_recv_buff(void){
+managed_recv_buffer::sptr phony_zero_copy_recv_if::get_recv_buff(size_t timeout_ms){
     //allocate memory
     boost::uint8_t *recv_mem = new boost::uint8_t[_impl->max_buff_size];
 
     //call recv() with timeout option
-    ssize_t num_bytes = this->recv(boost::asio::buffer(recv_mem, _impl->max_buff_size));
+    ssize_t num_bytes = this->recv(boost::asio::buffer(recv_mem, _impl->max_buff_size), timeout_ms);
 
     if (num_bytes <= 0) return managed_recv_buffer::sptr(); //NULL sptr