/ - Diff - uhd - Ettus Research LLC

         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)

     //
     // 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;
+    }

     //
     // 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 */

     // 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,
-...
                       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);
+    }
-...
+    }
     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,
-...
     /***********************************************************************
      * 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;
+    }

     //
     // 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;
+    }

     // 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>
-...
     using namespace uhd::transport;
     static int libusb_debug_level = 3;
     const int libusb_debug_level = 3;
     const int libusb_timeout = 0;
     /***********************************************************************
      * Helper functions
-...
             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;
-...
         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,
-...
     };
     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,
-...
        _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,
-...
+    }
     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();
-...
     /***********************************************************************
      * 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,

         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);
+            }
-...
         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);
+            }
+        }
-...
         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
 ,             // IN endpoint
 ,             // OUT endpoint
 * (1 << 20), // buffer size

uhd

Revision fe7df530