usrp1: Modifiy USB transport implementations to use new interface

Common libusb1 code is consolidated in the libusb base file.

7 files changed, 322 insertions, 314 deletions

diff --git a/host/lib/transport/CMakeLists.txt b/host/lib/transport/CMakeLists.txt
index 627d2d806..753fd5e85 100644
--- a/host/lib/transport/CMakeLists.txt
+++ b/host/lib/transport/CMakeLists.txt
@@ -29,6 +29,8 @@ IF(LIBUSB_FOUND)
     LIBUHD_APPEND_SOURCES(
         ${CMAKE_SOURCE_DIR}/lib/transport/libusb1_control.cpp
         ${CMAKE_SOURCE_DIR}/lib/transport/libusb1_zero_copy.cpp
+        ${CMAKE_SOURCE_DIR}/lib/transport/libusb1_base.cpp
+        ${CMAKE_SOURCE_DIR}/lib/transport/libusb1_device_handle.cpp
     )
     SET(HAVE_USB_SUPPORT TRUE)
 ENDIF(LIBUSB_FOUND)
diff --git a/host/lib/transport/libusb1_base.cpp b/host/lib/transport/libusb1_base.cpp
new file mode 100644
index 000000000..6965de214
--- /dev/null
+++ b/host/lib/transport/libusb1_base.cpp
@@ -0,0 +1,118 @@
+//
+// 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 <iostream>
+
+using namespace uhd::transport;
+
+void libusb::init(libusb_context **ctx, int debug_level)
+{
+    if (libusb_init(ctx) < 0)
+        std::cerr << "error: libusb_init" << std::endl;
+
+    libusb_set_debug(*ctx, debug_level);
+}
+
+
+libusb_device_handle *libusb::open_device(libusb_context *ctx,
+                                          usb_device_handle::sptr handle)
+{
+    libusb_device **dev_list;
+    libusb_device_handle *dev_handle;
+
+    ssize_t dev_cnt = libusb_get_device_list(ctx, &dev_list);
+
+    //find and open the receive device
+    for (ssize_t i = 0; i < dev_cnt; i++) {
+        libusb_device *dev = dev_list[i];
+
+        if (compare_device(dev, handle)) {
+            libusb_open(dev, &dev_handle);
+            break;
+        }
+    }
+
+    libusb_free_device_list(dev_list, 0);
+
+    return dev_handle;
+}
+
+
+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::uint8_t device_addr = handle->get_device_addr();
+
+    libusb_device_descriptor libusb_desc;
+    if (libusb_get_device_descriptor(dev, &libusb_desc) < 0)
+        return false;
+    if (serial != get_serial(dev))
+        return false;
+    if (vendor_id != libusb_desc.idVendor)
+        return false;
+    if (product_id != libusb_desc.idProduct)
+        return false; 
+    if (device_addr != libusb_get_device_address(dev))
+        return false;
+
+    return true;
+}
+
+
+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;
+    }
+    else {
+        return true;
+    }
+}
+
+
+std::string libusb::get_serial(libusb_device *dev)
+{
+    unsigned char buff[32];
+
+    libusb_device_descriptor desc;
+    if (libusb_get_device_descriptor(dev, &desc) < 0)
+        return "";
+
+    if (desc.iSerialNumber == 0)
+        return "";
+
+    //open the device because we have to
+    libusb_device_handle *dev_handle;
+    if (libusb_open(dev, &dev_handle) < 0)
+        return "";
+
+    if (libusb_get_string_descriptor_ascii(dev_handle, desc.iSerialNumber,
+                                           buff, sizeof(buff)) < 0) {
+        return "";
+    }
+
+    libusb_close(dev_handle);
+
+    return (char*) buff;
+}
diff --git a/host/lib/transport/libusb1_base.hpp b/host/lib/transport/libusb1_base.hpp
new file mode 100644
index 000000000..ae560cd52
--- /dev/null
+++ b/host/lib/transport/libusb1_base.hpp
@@ -0,0 +1,42 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_TRANSPORT_LIBUSB_HPP
+#define INCLUDED_TRANSPORT_LIBUSB_HPP
+
+#include <uhd/config.hpp>
+#include <uhd/transport/usb_device_handle.hpp>
+#include <libusb-1.0/libusb.h>
+
+namespace uhd { namespace transport {
+
+namespace libusb {
+    void init(libusb_context **ctx, int debug_level);
+
+    libusb_device_handle *open_device(libusb_context *ctx,
+                                      usb_device_handle::sptr handle);
+
+    bool compare_device(libusb_device *dev, usb_device_handle::sptr handle);
+
+    bool open_interface(libusb_device_handle *dev_handle, int interface);
+
+    std::string get_serial(libusb_device *dev);
+}
+
+}} //namespace
+
+#endif /* INCLUDED_TRANSPORT_LIBUSB_HPP */
diff --git a/host/lib/transport/libusb1_control.cpp b/host/lib/transport/libusb1_control.cpp
index c2f7060e8..8bf271256 100644
--- a/host/lib/transport/libusb1_control.cpp
+++ b/host/lib/transport/libusb1_control.cpp
@@ -15,24 +15,20 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include <uhd/types/usb_descriptor.hpp>
+#include "libusb1_base.hpp"
 #include <uhd/transport/usb_control.hpp>
-#include <libusb-1.0/libusb.h>
-#include <boost/asio.hpp>
-#include <stdexcept>
-#include <iostream>
 
 using namespace uhd::transport;
 
-static int libusb_debug_level = 0;
-static int libusb_timeout = 0;
+const int libusb_debug_level = 3;
+const int libusb_timeout = 0;
 
 /***********************************************************************
  * libusb-1.0 implementation of USB control transport
  **********************************************************************/
 class libusb_control_impl : public usb_control {
 public:
-    libusb_control_impl(uhd::usb_descriptor_t descriptor);
+    libusb_control_impl(usb_device_handle::sptr handle);
     ~libusb_control_impl();
 
     size_t submit(boost::uint8_t request_type,
@@ -42,34 +38,19 @@ public:
                   unsigned char *buff,
                   boost::uint16_t length); 
 
-    static uhd::usb_descriptor_t create_descriptor(libusb_device *dev);
-    static std::string get_serial(libusb_device *dev);
-
 private:
-    uhd::usb_descriptor_t _descriptor;
-
     libusb_context       *_ctx;
     libusb_device_handle *_dev_handle;
-
-    bool open_device();
-    bool open_interface();
-    bool compare_device(libusb_device *dev, uhd::usb_descriptor_t descriptor);
 };
 
 
-libusb_control_impl::libusb_control_impl(uhd::usb_descriptor_t descriptor)
- :  _descriptor(descriptor), _ctx(NULL), _dev_handle(NULL)
+libusb_control_impl::libusb_control_impl(usb_device_handle::sptr handle)
 {
-    if (libusb_init(&_ctx) < 0)
-        throw std::runtime_error("USB: failed to initialize libusb");
+    libusb::init(&_ctx, libusb_debug_level);
 
-    libusb_set_debug(_ctx, libusb_debug_level);
+    _dev_handle = libusb::open_device(_ctx, handle);
 
-    if (!open_device())
-        throw std::runtime_error("USB: failed to open device");
-
-    if (!open_interface())
-        throw std::runtime_error("USB: failed to open device interface");
+    libusb::open_interface(_dev_handle, 0);
 }
 
 
@@ -80,111 +61,6 @@ libusb_control_impl::~libusb_control_impl()
 }
 
 
-uhd::usb_descriptor_t libusb_control_impl::create_descriptor(libusb_device *dev)
-{
-    libusb_device_descriptor desc;
-
-    if (libusb_get_device_descriptor(dev, &desc) < 0)
-        throw std::runtime_error("USB: failed to get device descriptor");
-
-    uhd::usb_descriptor_t descriptor;
-
-    descriptor.serial      = get_serial(dev); 
-    descriptor.product_id  = desc.idProduct;   
-    descriptor.vendor_id   = desc.idVendor;
-    descriptor.device_addr = libusb_get_device_address(dev);
-
-    return descriptor;
-}
-
-
-std::string libusb_control_impl::get_serial(libusb_device *dev)
-{
-    unsigned char buff[32];
-
-    libusb_device_descriptor desc;
-    if (libusb_get_device_descriptor(dev, &desc) < 0)
-        return "";
-
-    if (desc.iSerialNumber == 0)
-        return "";
-
-    //open the device because we have to
-    libusb_device_handle *dev_handle;
-    if (libusb_open(dev, &dev_handle) < 0)
-        return "";
-
-    if (libusb_get_string_descriptor_ascii(dev_handle, desc.iSerialNumber,
-                                           buff, sizeof(buff)) < 0) {
-        return "";
-    }
-
-    libusb_close(dev_handle);
-
-    return (char*) buff;
-}
-
-
-bool libusb_control_impl::open_device()
-{
-    libusb_device **list;
-    libusb_device *dev;
-
-    ssize_t cnt = libusb_get_device_list(_ctx, &list);
-
-    if (cnt < 0)
-        return cnt;
-
-    ssize_t i = 0;
-    for (i = 0; i < cnt; i++) {
-        dev = list[i];
-        if (compare_device(dev, _descriptor))
-            goto found;
-    } 
-    return false;
-
-found:
-    int ret;
-    if ((ret = libusb_open(dev, &_dev_handle)) < 0)
-        return false;
-    else 
-        return true;
-}
-
-
-bool libusb_control_impl::compare_device(libusb_device *dev,
-                                         uhd::usb_descriptor_t descriptor)
-{
-    std::string serial         = descriptor.serial;
-    boost::uint16_t vendor_id  = descriptor.vendor_id;
-    boost::uint16_t product_id = descriptor.product_id;
-    boost::uint8_t device_addr = descriptor.device_addr;
-
-    libusb_device_descriptor libusb_desc;
-    if (libusb_get_device_descriptor(dev, &libusb_desc) < 0)
-        return false;
-    if (serial != get_serial(dev))
-        return false;
-    if (vendor_id != libusb_desc.idVendor)
-        return false;
-    if (product_id != libusb_desc.idProduct)
-        return false; 
-    if (device_addr != libusb_get_device_address(dev))
-        return false;
-
-    return true;
-}
-
-
-bool libusb_control_impl::open_interface()
-{
-    if (libusb_claim_interface(_dev_handle, 0) < 0)
-        return false;
-    else
-        return true;
-}
-
-
 size_t libusb_control_impl::submit(boost::uint8_t request_type,
                                    boost::uint8_t request,
                                    boost::uint16_t value,
@@ -206,33 +82,7 @@ size_t libusb_control_impl::submit(boost::uint8_t request_type,
 /***********************************************************************
  * USB control public make functions
  **********************************************************************/
-usb_control::sptr usb_control::make(uhd::usb_descriptor_t descriptor)
+usb_control::sptr usb_control::make(usb_device_handle::sptr handle)
 {
-    return sptr(new libusb_control_impl(descriptor));
+    return sptr(new libusb_control_impl(handle));
 }
-
-uhd::usb_descriptors_t usb_control::get_device_list()
-{
-    libusb_device **list;
-    uhd::usb_descriptors_t descriptors;
-
-    if (libusb_init(NULL) < 0)
-        throw std::runtime_error("USB: failed to initialize libusb");
-
-    ssize_t cnt = libusb_get_device_list(NULL, &list);
-
-    if (cnt < 0)
-        throw std::runtime_error("USB: failed to get device list");
-
-    ssize_t i = 0;
-    for (i = 0; i < cnt; i++) {
-        libusb_device *dev = list[i];
-        descriptors.push_back(libusb_control_impl::create_descriptor(dev));
-    } 
-
-    libusb_free_device_list(list, 0);
-    libusb_exit(NULL);
-    return descriptors;
-}
-
-
diff --git a/host/lib/transport/libusb1_device_handle.cpp b/host/lib/transport/libusb1_device_handle.cpp
new file mode 100644
index 000000000..f80090f15
--- /dev/null
+++ b/host/lib/transport/libusb1_device_handle.cpp
@@ -0,0 +1,114 @@
+//
+// 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>
+
+using namespace uhd::transport;
+
+const int libusb_debug_level = 3;
+
+class libusb1_device_handle_impl : public usb_device_handle {
+public:
+    libusb1_device_handle_impl(std::string serial,
+                               boost::uint32_t product_id,
+                               boost::uint32_t vendor_id,
+                               boost::uint32_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::uint32_t _product_id;
+    boost::uint32_t _vendor_id;
+    boost::uint32_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::uint32_t product_id  = desc.idProduct;
+    boost::uint32_t vendor_id   = desc.idVendor;
+    boost::uint32_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()
+{
+    libusb_context *ctx = NULL;
+    libusb_device **list;
+    std::vector<usb_device_handle::sptr> device_list;
+
+    libusb::init(&ctx, libusb_debug_level);
+
+    ssize_t cnt = libusb_get_device_list(ctx, &list);
+
+    if (cnt < 0)
+        throw std::runtime_error("USB: enumeration failed");
+
+    ssize_t i = 0;
+    for (i = 0; i < cnt; i++) {
+        libusb_device *dev = list[i];
+        device_list.push_back(make_usb_device_handle(dev));
+    }
+
+    libusb_free_device_list(list, 0);
+    libusb_exit(ctx);
+    return device_list; 
+}
diff --git a/host/lib/transport/libusb1_zero_copy.cpp b/host/lib/transport/libusb1_zero_copy.cpp
index 39617e4dd..55aa10cbb 100644
--- a/host/lib/transport/libusb1_zero_copy.cpp
+++ b/host/lib/transport/libusb1_zero_copy.cpp
@@ -15,10 +15,9 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-
+#include "libusb1_base.hpp"
 #include <uhd/transport/usb_zero_copy.hpp>
 #include <uhd/utils/assert.hpp>
-#include <libusb-1.0/libusb.h>
 #include <boost/asio.hpp>
 #include <boost/format.hpp>
 #include <iostream>
@@ -26,7 +25,8 @@
 
 using namespace uhd::transport;
 
-static int libusb_debug_level = 3;
+const int libusb_debug_level = 3;
+const int libusb_timeout = 0;
 
 /***********************************************************************
  * Helper functions
@@ -347,7 +347,7 @@ void usb_endpoint::print_transfer_status(libusb_transfer *lut)
         std::cerr << "USB: transfer timed out" << std::endl;
         break;
     case LIBUSB_TRANSFER_STALL:
-        std::cerr << "USB: halt condition detected (endpoint stalled)" << std::endl;
+        std::cerr << "USB: halt condition detected (stalled)" << std::endl;
         break;
     case LIBUSB_TRANSFER_ERROR:
         std::cerr << "USB: transfer failed" << std::endl;
@@ -606,26 +606,17 @@ private:
     libusb_device_handle *_rx_dev_handle;
     libusb_device_handle *_tx_dev_handle;
 
-    int _rx_endpoint;
-    int _tx_endpoint;
-
     size_t _recv_buff_size;
     size_t _send_buff_size;
     size_t _num_frames;
 
-    bool open_device(uhd::usb_descriptor_t descriptor);
-    bool open_interface(libusb_device_handle *dev_handle, int interface);
-    bool compare_device(libusb_device *dev, uhd::usb_descriptor_t descriptor);
-
-    std::string get_serial(libusb_device *dev);
-
 public:
     typedef boost::shared_ptr<libusb_zero_copy_impl> sptr;
 
     /*
      * Structors
      */
-    libusb_zero_copy_impl(uhd::usb_descriptor_t descriptor,
+    libusb_zero_copy_impl(usb_device_handle::sptr handle,
                           unsigned int rx_endpoint,
                           unsigned int tx_endpoint,
                           size_t recv_buff_size,
@@ -641,7 +632,7 @@ public:
 };
 
 
-libusb_zero_copy_impl::libusb_zero_copy_impl(uhd::usb_descriptor_t descriptor,
+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,
@@ -650,19 +641,16 @@ libusb_zero_copy_impl::libusb_zero_copy_impl(uhd::usb_descriptor_t descriptor,
    _recv_buff_size(block_size), _send_buff_size(block_size),
    _num_frames(buff_size / block_size)
 {
-    if (libusb_init(&_rx_ctx) < 0)
-        std::cerr << "error: libusb_init" << std::endl;
+    libusb::init(&_rx_ctx, libusb_debug_level);
+    libusb::init(&_tx_ctx, libusb_debug_level);
 
-    if (libusb_init(&_tx_ctx) < 0)
-        std::cerr << "error: libusb_init" << std::endl;
+    UHD_ASSERT_THROW((_rx_ctx != NULL) && (_tx_ctx != NULL));
 
-    libusb_set_debug(_rx_ctx, libusb_debug_level);
-    libusb_set_debug(_tx_ctx, libusb_debug_level);
+    _rx_dev_handle = libusb::open_device(_rx_ctx, handle);
+    _tx_dev_handle = libusb::open_device(_tx_ctx, handle);
 
-    open_device(descriptor);
-
-    open_interface(_rx_dev_handle, 2);
-    open_interface(_tx_dev_handle, 1);
+    libusb::open_interface(_rx_dev_handle, 2);
+    libusb::open_interface(_tx_dev_handle, 1);
 
     _rx_ep = new usb_endpoint(_rx_dev_handle,
                               _rx_ctx,
@@ -693,117 +681,6 @@ libusb_zero_copy_impl::~libusb_zero_copy_impl()
 }
 
 
-bool libusb_zero_copy_impl::open_device(uhd::usb_descriptor_t descriptor)
-{
-    libusb_device **rx_list;
-    libusb_device **tx_list;
-
-    bool rx_found = false;
-    bool tx_found = false;
-
-    ssize_t rx_cnt = libusb_get_device_list(_rx_ctx, &rx_list);
-    ssize_t tx_cnt = libusb_get_device_list(_tx_ctx, &tx_list);
-
-    if ((rx_cnt < 0) | (tx_cnt < 0) | (rx_cnt != tx_cnt))
-        return false;
-
-    //find and open the receive device
-    for (ssize_t i = 0; i < rx_cnt; i++) {
-        libusb_device *dev = rx_list[i];
-
-        if (compare_device(dev, descriptor)) {
-            libusb_open(dev, &_rx_dev_handle);
-            rx_found = true;
-            break;
-        }
-    }
-
-    //find and open the transmit device
-    for (ssize_t i = 0; i < tx_cnt; i++) {
-        libusb_device *dev = tx_list[i];
-
-        if (compare_device(dev, descriptor)) {
-            libusb_open(dev, &_tx_dev_handle);
-            tx_found = true;
-        }
-    }
-
-    libusb_free_device_list(rx_list, 0);
-    libusb_free_device_list(tx_list, 0);
-
-    if (tx_found && rx_found)
-        return true;
-    else
-        return false;
-}
-
-bool libusb_zero_copy_impl::compare_device(libusb_device *dev,
-                                        uhd::usb_descriptor_t descriptor)
-{
-    std::string serial         = descriptor.serial;
-    boost::uint16_t vendor_id  = descriptor.vendor_id;
-    boost::uint16_t product_id = descriptor.product_id;
-    boost::uint8_t device_addr = descriptor.device_addr;
-
-    libusb_device_descriptor desc;
-    libusb_get_device_descriptor(dev, &desc);
-
-    if (serial.compare(get_serial(dev)))
-        return false;
-    if (vendor_id != desc.idVendor)
-        return false;
-    if (product_id != desc.idProduct)
-        return false;
-    if (device_addr != libusb_get_device_address(dev))
-        return false;
-
-    return true;
-}
-
-bool libusb_zero_copy_impl::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;
-    }
-    else {
-        return true;
-    }
-}
-
-std::string libusb_zero_copy_impl::get_serial(libusb_device *dev)
-{
-    unsigned char buff[32];
-
-    libusb_device_descriptor desc;
-    if (libusb_get_device_descriptor(dev, &desc) < 0) {
-        std::cerr << "error: libusb_get_device_descriptor()" << std::endl;
-        return "";
-    }
-
-    if (desc.iSerialNumber == 0)
-        return "";
-
-    //open the device because we have to
-    libusb_device_handle *dev_handle;
-    if (libusb_open(dev, &dev_handle) < 0) {
-        return "";
-    }
-
-    if (libusb_get_string_descriptor_ascii(dev_handle, desc.iSerialNumber,
-                                           buff, sizeof(buff)) < 0) {
-        std::cerr << "error: libusb_get_string_descriptor_ascii()" << std::endl;
-        return "";
-    }
-
-    libusb_close(dev_handle);
-
-    return (char*) buff;
-}
-
-
 managed_recv_buffer::sptr libusb_zero_copy_impl::get_recv_buff()
 {
     libusb_transfer *lut = _rx_ep->get_completed_transfer();
@@ -836,14 +713,14 @@ managed_send_buffer::sptr libusb_zero_copy_impl::get_send_buff()
 /***********************************************************************
  * USB zero_copy make functions
  **********************************************************************/
-usb_zero_copy::sptr usb_zero_copy::make(uhd::usb_descriptor_t descriptor,
+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(descriptor,
+    return sptr(new libusb_zero_copy_impl(handle,
                                           rx_endpoint,
                                           tx_endpoint,
                                           buff_size, 
diff --git a/host/lib/usrp/usrp1/usrp1_impl.cpp b/host/lib/usrp/usrp1/usrp1_impl.cpp
index ee6fe6e99..a4effb907 100644
--- a/host/lib/usrp/usrp1/usrp1_impl.cpp
+++ b/host/lib/usrp/usrp1/usrp1_impl.cpp
@@ -48,13 +48,15 @@ static device_addrs_t usrp1_find(const device_addr_t &hint)
     if (hint.has_key("type") and hint["type"] != "usrp1") return usrp1_addrs;
 
     //see what we got on the USB bus
-    usb_descriptors_t usb_descriptors;
-    usb_descriptors = usb_control::get_device_list();
+    std::vector<usb_device_handle::sptr> device_list =
+        usb_device_handle::get_device_list();
 
     //find the usrps and load firmware
-    BOOST_FOREACH(usb_descriptor_t desc, usb_descriptors) {
-        if (desc.vendor_id == 0xfffe && desc.product_id == 0x0002) {
-            usb_control::sptr ctrl_transport = usb_control::make(desc);
+    BOOST_FOREACH(usb_device_handle::sptr handle, device_list) {
+        if (handle->get_vendor_id() == 0xfffe &&
+            handle->get_product_id() == 0x0002) {
+
+            usb_control::sptr ctrl_transport = usb_control::make(handle);
             usrp_ctrl::sptr usrp_ctrl = usrp_ctrl::make(ctrl_transport);
             usrp_ctrl->usrp_load_firmware(filename);
         }
@@ -64,13 +66,15 @@ static device_addrs_t usrp1_find(const device_addr_t &hint)
     sleep(1);
 
     //get descriptors again with serial number
-    usb_descriptors = usb_control::get_device_list();
+    device_list = usb_device_handle::get_device_list();
+
+    BOOST_FOREACH(usb_device_handle::sptr handle, device_list) {
+        if (handle->get_vendor_id() == 0xfffe &&
+            handle->get_product_id() == 0x0002) {
 
-    BOOST_FOREACH(usb_descriptor_t desc, usb_descriptors) {
-        if (desc.vendor_id == 0xfffe && desc.product_id == 0x0002) {
             device_addr_t new_addr;
             new_addr["type"] = "usrp1";
-            new_addr["serial"] = desc.serial;
+            new_addr["serial"] = handle->get_serial();
             usrp1_addrs.push_back(new_addr);
         }
     }
@@ -93,22 +97,23 @@ static device::sptr usrp1_make(const device_addr_t &device_addr)
     std::cout << "Make usrp1 with " << filename << std::endl;
 
     //try to match the given device address with something on the USB bus
-    usb_descriptors_t usb_descriptors;
-    usb_descriptors = usb_control::get_device_list();
+    std::vector<usb_device_handle::sptr> device_list =
+        usb_device_handle::get_device_list();
 
     //create data and control transports
     usb_zero_copy::sptr data_transport;
     usrp_ctrl::sptr usrp_ctrl;
 
-    BOOST_FOREACH(usb_descriptor_t desc, usb_descriptors) {
-        if (desc.serial == device_addr["serial"]
-            && desc.vendor_id == 0xfffe && desc.product_id == 0x0002) {
+    BOOST_FOREACH(usb_device_handle::sptr handle, device_list) {
+        if (handle->get_vendor_id() == 0xfffe &&
+            handle->get_product_id() == 0x0002 &&
+            handle->get_serial() == device_addr["serial"]) {
 
-            usb_control::sptr ctrl_transport = usb_control::make(desc);
+            usb_control::sptr ctrl_transport = usb_control::make(handle);
             usrp_ctrl = usrp_ctrl::make(ctrl_transport);
             usrp_ctrl->usrp_load_fpga(filename);
 
-            data_transport = usb_zero_copy::make(desc,          // identifier
+            data_transport = usb_zero_copy::make(handle,        // identifier
                                                  6,             // IN endpoint
                                                  2,             // OUT endpoint
                                                  2 * (1 << 20), // buffer size