summaryrefslogtreecommitdiffstats
path: root/host/lib
diff options
context:
space:
mode:
Diffstat (limited to 'host/lib')
-rw-r--r--host/lib/transport/CMakeLists.txt2
-rw-r--r--host/lib/transport/libusb1_base.cpp118
-rw-r--r--host/lib/transport/libusb1_base.hpp42
-rw-r--r--host/lib/transport/libusb1_control.cpp170
-rw-r--r--host/lib/transport/libusb1_device_handle.cpp114
-rw-r--r--host/lib/transport/libusb1_zero_copy.cpp153
-rw-r--r--host/lib/usrp/usrp1/clock_ctrl.cpp2
-rw-r--r--host/lib/usrp/usrp1/codec_ctrl.cpp174
-rw-r--r--host/lib/usrp/usrp1/codec_ctrl.hpp8
-rw-r--r--host/lib/usrp/usrp1/dsp_impl.cpp30
-rw-r--r--host/lib/usrp/usrp1/io_impl.cpp341
-rw-r--r--host/lib/usrp/usrp1/mboard_impl.cpp6
-rw-r--r--host/lib/usrp/usrp1/usrp1_iface.cpp12
-rw-r--r--host/lib/usrp/usrp1/usrp1_impl.cpp45
-rw-r--r--host/lib/usrp/usrp1/usrp1_impl.hpp4
15 files changed, 655 insertions, 566 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/clock_ctrl.cpp b/host/lib/usrp/usrp1/clock_ctrl.cpp
index c83ad4c68..54f7b0b98 100644
--- a/host/lib/usrp/usrp1/clock_ctrl.cpp
+++ b/host/lib/usrp/usrp1/clock_ctrl.cpp
@@ -64,7 +64,7 @@ public:
rates.push_back(master_clock_rate / div);
return rates;
#else
- return std::vector<double>(1, 64e6);
+ return std::vector<double>(1, master_clock_rate);
#endif
}
diff --git a/host/lib/usrp/usrp1/codec_ctrl.cpp b/host/lib/usrp/usrp1/codec_ctrl.cpp
index 01617de94..6751b9b7e 100644
--- a/host/lib/usrp/usrp1/codec_ctrl.cpp
+++ b/host/lib/usrp/usrp1/codec_ctrl.cpp
@@ -17,6 +17,7 @@
#include "codec_ctrl.hpp"
#include "usrp_commands.h"
+#include "clock_ctrl.hpp"
#include "ad9862_regs.hpp"
#include <uhd/types/dict.hpp>
#include <uhd/utils/assert.hpp>
@@ -43,7 +44,9 @@ const gain_range_t usrp1_codec_ctrl::rx_pga_gain_range(0, 20, 1);
class usrp1_codec_ctrl_impl : public usrp1_codec_ctrl {
public:
//structors
- usrp1_codec_ctrl_impl(usrp1_iface::sptr iface, int spi_slave);
+ usrp1_codec_ctrl_impl(usrp1_iface::sptr iface,
+ usrp1_clock_ctrl::sptr clock,
+ int spi_slave);
~usrp1_codec_ctrl_impl(void);
//aux adc and dac control
@@ -51,7 +54,7 @@ public:
void write_aux_dac(aux_dac_t which, float volts);
//duc control
- bool set_duc_freq(double freq);
+ void set_duc_freq(double freq);
//pga gain control
void set_tx_pga_gain(float);
@@ -61,25 +64,26 @@ public:
private:
usrp1_iface::sptr _iface;
+ usrp1_clock_ctrl::sptr _clock_ctrl;
int _spi_slave;
ad9862_regs_t _ad9862_regs;
aux_adc_t _last_aux_adc_a, _last_aux_adc_b;
void send_reg(boost::uint8_t addr);
void recv_reg(boost::uint8_t addr);
- //FIXME: poison
- double _tx_freq[4];
- unsigned int compute_freq_control_word_9862 (double master_freq,
- double target_freq,
- double *actual_freq);
+ double coarse_tune(double codec_rate, double freq);
+ double fine_tune(double codec_rate, double freq);
};
/***********************************************************************
* Codec Control Structors
**********************************************************************/
-usrp1_codec_ctrl_impl::usrp1_codec_ctrl_impl(usrp1_iface::sptr iface, int spi_slave)
+usrp1_codec_ctrl_impl::usrp1_codec_ctrl_impl(usrp1_iface::sptr iface,
+ usrp1_clock_ctrl::sptr clock,
+ int spi_slave)
{
_iface = iface;
+ _clock_ctrl = clock;
_spi_slave = spi_slave;
//soft reset
@@ -96,15 +100,15 @@ usrp1_codec_ctrl_impl::usrp1_codec_ctrl_impl(usrp1_iface::sptr iface, int spi_sl
_ad9862_regs.byp_buffer_b = 1;
_ad9862_regs.buffer_a_pd = 1;
_ad9862_regs.buffer_b_pd = 1;
- _ad9862_regs.rx_pga_a = 0;//0x1f; //TODO bring under api control
- _ad9862_regs.rx_pga_b = 0;//0x1f; //TODO bring under api control
+ _ad9862_regs.rx_pga_a = 0;
+ _ad9862_regs.rx_pga_b = 0;
_ad9862_regs.rx_twos_comp = 1;
_ad9862_regs.rx_hilbert = ad9862_regs_t::RX_HILBERT_DIS;
//setup tx side of codec
_ad9862_regs.two_data_paths = ad9862_regs_t::TWO_DATA_PATHS_BOTH;
_ad9862_regs.interleaved = ad9862_regs_t::INTERLEAVED_INTERLEAVED;
- _ad9862_regs.tx_pga_gain = 199; //TODO bring under api control
+ _ad9862_regs.tx_pga_gain = 199;
_ad9862_regs.tx_hilbert = ad9862_regs_t::TX_HILBERT_DIS;
_ad9862_regs.interp = ad9862_regs_t::INTERP_4;
_ad9862_regs.tx_twos_comp = 1;
@@ -152,8 +156,8 @@ usrp1_codec_ctrl_impl::~usrp1_codec_ctrl_impl(void)
**********************************************************************/
void usrp1_codec_ctrl_impl::set_tx_pga_gain(float gain)
{
- int gain_word = int(63*(gain - tx_pga_gain_range.min)/(tx_pga_gain_range.max - tx_pga_gain_range.min));
- _ad9862_regs.tx_pga_gain = std::clip(gain_word, 0, 63);
+ int gain_word = int(255*(gain - tx_pga_gain_range.min)/(tx_pga_gain_range.max - tx_pga_gain_range.min));
+ _ad9862_regs.tx_pga_gain = std::clip(gain_word, 0, 255);
this->send_reg(16);
}
@@ -324,118 +328,102 @@ void usrp1_codec_ctrl_impl::recv_reg(boost::uint8_t addr)
/***********************************************************************
* DUC tuning
**********************************************************************/
-unsigned int usrp1_codec_ctrl_impl::compute_freq_control_word_9862(
- double master_freq, double target_freq, double *actual_freq)
+double usrp1_codec_ctrl_impl::coarse_tune(double codec_rate, double freq)
{
- double sign = 1.0;
-
- if (target_freq < 0)
- sign = -1.0;
-
- int v = (int) rint (fabs (target_freq) / master_freq * pow (2.0, 24.0));
- *actual_freq = v * master_freq / pow (2.0, 24.0) * sign;
-
- std::cout << boost::format(
- "compute_freq_control_word_9862: target = %g actual = %g delta = %g v = %8d\n"
- ) % target_freq % *actual_freq % (*actual_freq - target_freq) % v;
-
- return (unsigned int) v;
-}
+ double coarse_freq;
-bool usrp1_codec_ctrl_impl::set_duc_freq(double freq)
-{
- int channel = 0;
- float dac_rate = 128e6;
-
- double coarse;
-
- std::cout << "duc_freq: " << freq << std::endl;
-
- // First coarse frequency
- double coarse_freq_1 = dac_rate / 8;
- // Second coarse frequency
- double coarse_freq_2 = dac_rate / 4;
- // Midpoint of [0 , freq1] range
+ double coarse_freq_1 = codec_rate / 8;
+ double coarse_freq_2 = codec_rate / 4;
double coarse_limit_1 = coarse_freq_1 / 2;
- // Midpoint of [freq1 , freq2] range
double coarse_limit_2 = (coarse_freq_1 + coarse_freq_2) / 2;
- // Highest meaningful frequency
- double high_limit = (double) 44e6 / 128e6 * dac_rate;
+ double max_freq = coarse_freq_2 + .09375 * codec_rate;
- if (freq < -high_limit) { // too low
+ if (freq < -max_freq) {
return false;
}
- else if (freq < -coarse_limit_2) { // For 64MHz: [-44, -24)
+ else if (freq < -coarse_limit_2) {
_ad9862_regs.neg_coarse_tune = ad9862_regs_t::NEG_COARSE_TUNE_NEG_SHIFT;
_ad9862_regs.coarse_mod = ad9862_regs_t::COARSE_MOD_FDAC_4;
- coarse = -coarse_freq_2;
+ coarse_freq = -coarse_freq_2;
}
- else if (freq < -coarse_limit_1) { // For 64MHz: [-24, -8)
+ else if (freq < -coarse_limit_1) {
_ad9862_regs.neg_coarse_tune = ad9862_regs_t::NEG_COARSE_TUNE_NEG_SHIFT;
_ad9862_regs.coarse_mod = ad9862_regs_t::COARSE_MOD_FDAC_8;
- coarse = -coarse_freq_1;
+ coarse_freq = -coarse_freq_1;
}
- else if (freq < coarse_limit_1) { // For 64MHz: [-8, 8)
+ else if (freq < coarse_limit_1) {
_ad9862_regs.coarse_mod = ad9862_regs_t::COARSE_MOD_BYPASS;
- coarse = 0;
+ coarse_freq = 0;
}
- else if (freq < coarse_limit_2) { // For 64MHz: [8, 24)
+ else if (freq < coarse_limit_2) {
_ad9862_regs.neg_coarse_tune = ad9862_regs_t::NEG_COARSE_TUNE_POS_SHIFT;
_ad9862_regs.coarse_mod = ad9862_regs_t::COARSE_MOD_FDAC_8;
- coarse = coarse_freq_1;
+ coarse_freq = coarse_freq_1;
}
- else if (freq <= high_limit) { // For 64MHz: [24, 44]
+ else if (freq <= max_freq) {
_ad9862_regs.neg_coarse_tune = ad9862_regs_t::NEG_COARSE_TUNE_POS_SHIFT;
_ad9862_regs.coarse_mod = ad9862_regs_t::COARSE_MOD_FDAC_4;
- coarse = coarse_freq_2;
+ coarse_freq = coarse_freq_2;
}
- else { // too high
- return false;
+ else {
+ return 0;
}
-
- double fine = freq - coarse;
-
- // Compute fine tuning word...
- // This assumes we're running the 4x on-chip interpolator.
- // (This is required to use the fine modulator.)
-
- unsigned int v = compute_freq_control_word_9862 (dac_rate / 4, fine,
- &_tx_freq[channel]);
-
- _tx_freq[channel] += coarse; // adjust actual
-
- boost::uint8_t high;
- boost::uint8_t mid;
- boost::uint8_t low;
-
- high = (v >> 16) & 0xff;
- mid = (v >> 8) & 0xff;
- low = (v >> 0) & 0xff;
-
- // write the fine tuning word
- _ad9862_regs.ftw_23_16 = high;
- _ad9862_regs.ftw_15_8 = mid;
- _ad9862_regs.ftw_7_0 = low;
-
- _ad9862_regs.fine_mode = ad9862_regs_t::FINE_MODE_NCO;
-
- if (fine < 0)
+
+ return coarse_freq;
+}
+
+double usrp1_codec_ctrl_impl::fine_tune(double codec_rate, double target_freq)
+{
+ static const double scale_factor = std::pow(2.0, 24);
+
+ boost::uint32_t freq_word = boost::uint32_t(
+ boost::math::round(abs((target_freq / codec_rate) * scale_factor)));
+
+ double actual_freq = freq_word * codec_rate / scale_factor;
+
+ if (target_freq < 0) {
_ad9862_regs.neg_fine_tune = ad9862_regs_t::NEG_FINE_TUNE_NEG_SHIFT;
- else
+ actual_freq = -actual_freq;
+ }
+ else {
_ad9862_regs.neg_fine_tune = ad9862_regs_t::NEG_FINE_TUNE_POS_SHIFT;
-
+ }
+
+ _ad9862_regs.fine_mode = ad9862_regs_t::FINE_MODE_NCO;
+ _ad9862_regs.ftw_23_16 = (freq_word >> 16) & 0xff;
+ _ad9862_regs.ftw_15_8 = (freq_word >> 8) & 0xff;
+ _ad9862_regs.ftw_7_0 = (freq_word >> 0) & 0xff;
+
+ return actual_freq;
+}
+
+void usrp1_codec_ctrl_impl::set_duc_freq(double freq)
+{
+ double codec_rate = _clock_ctrl->get_master_clock_freq() * 2;
+ double coarse_freq = coarse_tune(codec_rate, freq);
+ double fine_freq = fine_tune(codec_rate / 4, freq - coarse_freq);
+
+ if (codec_debug) {
+ std::cout << "ad9862 tuning result:" << std::endl;
+ std::cout << " requested: " << freq << std::endl;
+ std::cout << " actual: " << coarse_freq + fine_freq << std::endl;
+ std::cout << " coarse freq: " << coarse_freq << std::endl;
+ std::cout << " fine freq: " << fine_freq << std::endl;
+ std::cout << " codec rate: " << codec_rate << std::endl;
+ }
+
this->send_reg(20);
this->send_reg(21);
this->send_reg(22);
this->send_reg(23);
-
- return true;
}
/***********************************************************************
* Codec Control Make
**********************************************************************/
-usrp1_codec_ctrl::sptr usrp1_codec_ctrl::make(usrp1_iface::sptr iface, int spi_slave)
+usrp1_codec_ctrl::sptr usrp1_codec_ctrl::make(usrp1_iface::sptr iface,
+ usrp1_clock_ctrl::sptr clock,
+ int spi_slave)
{
- return sptr(new usrp1_codec_ctrl_impl(iface, spi_slave));
+ return sptr(new usrp1_codec_ctrl_impl(iface, clock, spi_slave));
}
diff --git a/host/lib/usrp/usrp1/codec_ctrl.hpp b/host/lib/usrp/usrp1/codec_ctrl.hpp
index 6440f97d1..259d10ef4 100644
--- a/host/lib/usrp/usrp1/codec_ctrl.hpp
+++ b/host/lib/usrp/usrp1/codec_ctrl.hpp
@@ -19,6 +19,7 @@
#define INCLUDED_USRP1_CODEC_CTRL_HPP
#include "usrp1_iface.hpp"
+#include "clock_ctrl.hpp"
#include <uhd/types/ranges.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
@@ -41,7 +42,9 @@ public:
* \param spi_slave which spi device
* \return the clock control object
*/
- static sptr make(usrp1_iface::sptr iface, int spi_slave);
+ static sptr make(usrp1_iface::sptr iface,
+ usrp1_clock_ctrl::sptr clock, int spi_slave
+ );
//! aux adc identifier constants
enum aux_adc_t{
@@ -87,7 +90,8 @@ public:
//! Get the RX PGA gain ('A' or 'B')
virtual float get_rx_pga_gain(char which) = 0;
- virtual bool set_duc_freq(double freq) = 0;
+ //! Set the TX modulator frequency
+ virtual void set_duc_freq(double freq) = 0;
};
#endif /* INCLUDED_USRP1_CODEC_CTRL_HPP */
diff --git a/host/lib/usrp/usrp1/dsp_impl.cpp b/host/lib/usrp/usrp1/dsp_impl.cpp
index 0db3cb473..ddd1e811b 100644
--- a/host/lib/usrp/usrp1/dsp_impl.cpp
+++ b/host/lib/usrp/usrp1/dsp_impl.cpp
@@ -73,31 +73,13 @@ void usrp1_impl::rx_dsp_get(const wax::obj &key, wax::obj &val)
/***********************************************************************
* RX DDC Set
**********************************************************************/
-unsigned int compute_freq_word(double master, double target)
-{
- static const int NBITS = 14;
- int v = (int) rint (target / master * pow(2.0, 32.0));
-
- if (0)
- v = (v >> (32 - NBITS)) << (32 - NBITS); // keep only top NBITS
-
- double actual_freq = v * master / pow(2.0, 32.0);
-
- if (0) std::cerr << boost::format(
- "compute_freq_control_word_fpga: target = %g actual = %g delta = %g\n"
- ) % target % actual_freq % (actual_freq - target);
-
- return (unsigned int) v;
-}
-
void usrp1_impl::rx_dsp_set(const wax::obj &key, const wax::obj &val)
{
switch(key.as<dsp_prop_t>()) {
case DSP_PROP_FREQ_SHIFT: {
double new_freq = val.as<double>();
- boost::uint32_t hw_freq_word = compute_freq_word(
- _clock_ctrl->get_master_clock_freq(), new_freq);
- _iface->poke32(FR_RX_FREQ_0, hw_freq_word);
+ _iface->poke32(FR_RX_FREQ_0,
+ -dsp_type1::calc_cordic_word_and_update(new_freq, _clock_ctrl->get_master_clock_freq()));
_tx_dsp_freq = new_freq;
return;
}
@@ -113,6 +95,8 @@ void usrp1_impl::rx_dsp_set(const wax::obj &key, const wax::obj &val)
}
_rx_dsp_decim = rate;
+ _rx_samps_per_poll_interval = 0.1 * _clock_ctrl->get_master_clock_freq() / rate;
+
_iface->poke32(FR_DECIM_RATE, _rx_dsp_decim/2 - 1);
}
return;
@@ -173,15 +157,15 @@ void usrp1_impl::tx_dsp_set(const wax::obj &key, const wax::obj &val)
{
switch(key.as<dsp_prop_t>()) {
+ // TODO: Set both codec frequencies until we have duality properties
case DSP_PROP_FREQ_SHIFT: {
double new_freq = val.as<double>();
_codec_ctrls[DBOARD_SLOT_A]->set_duc_freq(new_freq);
+ _codec_ctrls[DBOARD_SLOT_B]->set_duc_freq(new_freq);
_tx_dsp_freq = new_freq;
return;
}
- //TODO freq prop secondary: DBOARD_SLOT_B codec...
-
case DSP_PROP_HOST_RATE: {
unsigned int rate =
_clock_ctrl->get_master_clock_freq() * 2 / val.as<double>();
@@ -193,6 +177,8 @@ void usrp1_impl::tx_dsp_set(const wax::obj &key, const wax::obj &val)
}
_tx_dsp_interp = rate;
+ _tx_samps_per_poll_interval = 0.1 * _clock_ctrl->get_master_clock_freq() * 2 / rate;
+
_iface->poke32(FR_INTERP_RATE, _tx_dsp_interp / 4 - 1);
return;
}
diff --git a/host/lib/usrp/usrp1/io_impl.cpp b/host/lib/usrp/usrp1/io_impl.cpp
index 3f3e74b80..5e206b3d5 100644
--- a/host/lib/usrp/usrp1/io_impl.cpp
+++ b/host/lib/usrp/usrp1/io_impl.cpp
@@ -33,37 +33,67 @@ using namespace uhd::usrp;
using namespace uhd::transport;
namespace asio = boost::asio;
-/*
- * The FX2 firmware bursts data to the FPGA in 512 byte chunks so
- * maintain send state to make sure that happens.
- */
struct usrp1_send_state {
uhd::transport::managed_send_buffer::sptr send_buff;
- size_t bytes_used;
- size_t bytes_free;
+ size_t bytes_written;
+ size_t underrun_poll_samp_count;
+
+ size_t bytes_free()
+ {
+ if (send_buff != NULL)
+ return send_buff->size() - bytes_written;
+ else
+ return 0;
+ }
+};
+
+struct usrp1_recv_state {
+ uhd::transport::managed_recv_buffer::sptr recv_buff;
+ size_t bytes_read;
+ size_t overrun_poll_samp_count;
+
+ size_t bytes_avail()
+ {
+ if (recv_buff != NULL)
+ return recv_buff->size() - bytes_read;
+ else
+ return 0;
+ }
};
/***********************************************************************
* IO Implementation Details
**********************************************************************/
struct usrp1_impl::io_impl {
- io_impl(zero_copy_if::sptr zc_if);
+ io_impl();
~io_impl(void);
- bool get_recv_buff(managed_recv_buffer::sptr buff);
-
- //state management for the vrt packet handler code
- vrt_packet_handler::recv_state packet_handler_recv_state;
+ //state handling for buffer management
+ usrp1_recv_state recv_state;
usrp1_send_state send_state;
- zero_copy_if::sptr data_transport;
- unsigned int count;
+ //send transport management
+ bool get_send_buffer(zero_copy_if::sptr zc_if);
+ size_t copy_convert_send_samps(const void *buff, size_t num_samps,
+ size_t sample_offset, const io_type_t io_type,
+ otw_type_t otw_type);
+ bool conditional_buff_commit(bool force);
+ bool check_underrun(usrp_ctrl::sptr ctrl_if,
+ size_t poll_interval, bool force);
+
+ //recv transport management
+ bool get_recv_buffer(zero_copy_if::sptr zc_if);
+ size_t copy_convert_recv_samps(void *buff, size_t num_samps,
+ size_t sample_offset, const io_type_t io_type,
+ otw_type_t otw_type);
+ bool check_overrun(usrp_ctrl::sptr ctrl_if,
+ size_t poll_interval, bool force);
};
-usrp1_impl::io_impl::io_impl(zero_copy_if::sptr zc_if)
- : packet_handler_recv_state(1), data_transport(zc_if), count(0)
+usrp1_impl::io_impl::io_impl()
{
- /* NOP */
+ send_state.send_buff = uhd::transport::managed_send_buffer::sptr();
+ recv_state.recv_buff = uhd::transport::managed_recv_buffer::sptr();
}
usrp1_impl::io_impl::~io_impl(void)
@@ -81,12 +111,92 @@ void usrp1_impl::io_init(void)
_tx_otw_type.shift = 0;
_tx_otw_type.byteorder = otw_type_t::BO_LITTLE_ENDIAN;
- _io_impl = UHD_PIMPL_MAKE(io_impl, (_data_transport));
+ _io_impl = UHD_PIMPL_MAKE(io_impl, ());
}
/***********************************************************************
* Data Send
**********************************************************************/
+bool usrp1_impl::io_impl::get_send_buffer(zero_copy_if::sptr zc_if)
+{
+ if (send_state.send_buff == NULL) {
+
+ send_state.send_buff = zc_if->get_send_buff();
+ if (send_state.send_buff == NULL)
+ return false;
+
+ send_state.bytes_written = 0;
+ }
+
+ return true;
+}
+
+size_t usrp1_impl::io_impl::copy_convert_send_samps(const void *buff,
+ size_t num_samps,
+ size_t sample_offset,
+ const io_type_t io_type,
+ otw_type_t otw_type)
+{
+ UHD_ASSERT_THROW(send_state.bytes_free() % otw_type.get_sample_size() == 0);
+
+ size_t samps_free = send_state.bytes_free() / otw_type.get_sample_size();
+ size_t copy_samps = std::min(num_samps - sample_offset, samps_free);
+
+ const boost::uint8_t *io_mem =
+ reinterpret_cast<const boost::uint8_t *>(buff);
+
+ boost::uint8_t *otw_mem = send_state.send_buff->cast<boost::uint8_t *>();
+
+ convert_io_type_to_otw_type(io_mem + sample_offset * io_type.size,
+ io_type,
+ otw_mem + send_state.bytes_written,
+ otw_type,
+ copy_samps);
+
+ send_state.bytes_written += copy_samps * otw_type.get_sample_size();
+ send_state.underrun_poll_samp_count += copy_samps;
+
+ return copy_samps;
+}
+
+bool usrp1_impl::io_impl::conditional_buff_commit(bool force)
+{
+ if (send_state.bytes_written % 512)
+ return false;
+
+ if (force || send_state.bytes_free() == 0) {
+ send_state.send_buff->commit(send_state.bytes_written);
+ send_state.send_buff = uhd::transport::managed_send_buffer::sptr();
+ return true;
+ }
+
+ return false;
+}
+
+bool usrp1_impl::io_impl::check_underrun(usrp_ctrl::sptr ctrl_if,
+ size_t poll_interval,
+ bool force)
+{
+ unsigned char underrun = 0;
+
+ bool ready_to_poll = send_state.underrun_poll_samp_count > poll_interval;
+
+ if (force || ready_to_poll) {
+ int ret = ctrl_if->usrp_control_read(VRQ_GET_STATUS,
+ 0,
+ GS_TX_UNDERRUN,
+ &underrun, sizeof(char));
+ if (ret < 0)
+ std::cerr << "USRP: underrun check failed" << std::endl;
+ if (underrun)
+ std::cerr << "U" << std::endl;
+
+ send_state.underrun_poll_samp_count = 0;
+ }
+
+ return (bool) underrun;
+}
+
size_t usrp1_impl::send(const std::vector<const void *> &buffs,
size_t num_samps,
const tx_metadata_t &,
@@ -98,54 +208,21 @@ size_t usrp1_impl::send(const std::vector<const void *> &buffs,
size_t total_samps_sent = 0;
while (total_samps_sent < num_samps) {
-
- if (_io_impl->send_state.send_buff == NULL) {
- _io_impl->send_state.send_buff = _data_transport->get_send_buff();
- if (_io_impl->send_state.send_buff == NULL) {
- return 0;
- }
- _io_impl->send_state.bytes_used = 0;
- _io_impl->send_state.bytes_free = _io_impl->send_state.send_buff->size();
- }
-
- size_t copy_samps =
- std::min(num_samps - total_samps_sent, _io_impl->send_state.bytes_free / _tx_otw_type.get_sample_size());
-
- const boost::uint8_t *io_mem =
- reinterpret_cast<const boost::uint8_t *>(buffs[0]);
-
- boost::uint8_t *otw_mem = _io_impl->send_state.send_buff->cast<boost::uint8_t *>();
-
- // Type conversion and copy
- convert_io_type_to_otw_type(
- io_mem + total_samps_sent * io_type.size,
- io_type,
- otw_mem + _io_impl->send_state.bytes_used,
- _tx_otw_type,
- copy_samps);
-
- _io_impl->send_state.bytes_used += copy_samps * _tx_otw_type.get_sample_size();
- _io_impl->send_state.bytes_free -= copy_samps * _tx_otw_type.get_sample_size();
-
- if (_io_impl->send_state.bytes_free == 0) {
- _io_impl->send_state.send_buff->commit(_io_impl->send_state.bytes_used);
- _io_impl->send_state.send_buff = uhd::transport::managed_send_buffer::sptr();
- }
-
- total_samps_sent += copy_samps;
-
- //check for underruns
- if (!(_io_impl->count++ % 1000)) {
- unsigned char underrun;
- int ret = _ctrl_transport->usrp_control_read(VRQ_GET_STATUS,
- 0,
- GS_TX_UNDERRUN,
- &underrun, sizeof(char));
- if (ret < 0)
- std::cerr << "error: underrun check failed" << std::endl;
- if (underrun)
- std::cerr << "U" << std::endl;
- }
+ if (!_io_impl->get_send_buffer(_data_transport))
+ return 0;
+
+ total_samps_sent += _io_impl->copy_convert_send_samps(buffs[0],
+ num_samps,
+ total_samps_sent,
+ io_type,
+ _tx_otw_type);
+ if (total_samps_sent == num_samps)
+ _io_impl->conditional_buff_commit(true);
+ else
+ _io_impl->conditional_buff_commit(false);
+
+ _io_impl->check_underrun(_ctrl_transport,
+ _tx_samps_per_poll_interval, false);
}
return total_samps_sent;
@@ -154,17 +231,70 @@ size_t usrp1_impl::send(const std::vector<const void *> &buffs,
/***********************************************************************
* Data Recv
**********************************************************************/
-void _recv_helper(vrt_packet_handler::recv_state &state)
+bool usrp1_impl::io_impl::get_recv_buffer(zero_copy_if::sptr zc_if)
{
- size_t num_packet_words32 =
- state.managed_buffs[0]->size() / sizeof(boost::uint32_t);
+ if ((recv_state.recv_buff == NULL) || (recv_state.bytes_avail() == 0)) {
- const boost::uint32_t *data =
- state.managed_buffs[0]->cast<const boost::uint32_t *>();
+ recv_state.recv_buff = zc_if->get_recv_buff();
+ if (recv_state.recv_buff == NULL)
+ return false;
+
+ recv_state.bytes_read = 0;
+ }
- state.copy_buffs[0] = reinterpret_cast<const boost::uint8_t *>(data);
- size_t num_payload_bytes = num_packet_words32 * sizeof(boost::uint32_t);
- state.size_of_copy_buffs = num_payload_bytes;
+ return true;
+}
+
+size_t usrp1_impl::io_impl::copy_convert_recv_samps(void *buff,
+ size_t num_samps,
+ size_t sample_offset,
+ const io_type_t io_type,
+ otw_type_t otw_type)
+{
+ UHD_ASSERT_THROW(recv_state.bytes_avail() % otw_type.get_sample_size() == 0);
+
+ size_t samps_avail = recv_state.bytes_avail() / otw_type.get_sample_size();
+ size_t copy_samps = std::min(num_samps - sample_offset, samps_avail);
+
+ const boost::uint8_t *otw_mem =
+ recv_state.recv_buff->cast<const boost::uint8_t *>();
+
+ boost::uint8_t *io_mem = reinterpret_cast<boost::uint8_t *>(buff);
+
+ convert_otw_type_to_io_type(otw_mem + recv_state.bytes_read,
+ otw_type,
+ io_mem + sample_offset * io_type.size,
+ io_type,
+ copy_samps);
+
+ recv_state.bytes_read += copy_samps * otw_type.get_sample_size();
+ recv_state.overrun_poll_samp_count += copy_samps;
+
+ return copy_samps;
+}
+
+bool usrp1_impl::io_impl::check_overrun(usrp_ctrl::sptr ctrl_if,
+ size_t poll_interval,
+ bool force)
+{
+ unsigned char overrun = 0;
+
+ bool ready_to_poll = recv_state.overrun_poll_samp_count > poll_interval;
+
+ if (force || ready_to_poll) {
+ int ret = ctrl_if->usrp_control_read(VRQ_GET_STATUS,
+ 0,
+ GS_RX_OVERRUN,
+ &overrun, sizeof(char));
+ if (ret < 0)
+ std::cerr << "USRP: overrrun check failed" << std::endl;
+ if (overrun)
+ std::cerr << "O" << std::endl;
+
+ recv_state.overrun_poll_samp_count = 0;
+ }
+
+ return (bool) overrun;
}
size_t usrp1_impl::recv(const std::vector<void *> &buffs,
@@ -174,56 +304,23 @@ size_t usrp1_impl::recv(const std::vector<void *> &buffs,
recv_mode_t,
size_t)
{
- UHD_ASSERT_THROW(_io_impl->packet_handler_recv_state.width == 1);
UHD_ASSERT_THROW(buffs.size() == 1);
- size_t sent_samps = 0;
- size_t nsamps_to_copy = 0;;
-
- while (sent_samps < num_samps) {
- if (_io_impl->packet_handler_recv_state.size_of_copy_buffs == 0) {
- _io_impl->packet_handler_recv_state.fragment_offset_in_samps = 0;
- _io_impl->packet_handler_recv_state.managed_buffs[0] =
- _io_impl->data_transport->get_recv_buff();
-
- //timeout or something bad returns zero
- if (!_io_impl->packet_handler_recv_state.managed_buffs[0].get())
- return 0;
-
- _recv_helper(_io_impl->packet_handler_recv_state);
- }
-
- size_t bytes_per_item = _rx_otw_type.get_sample_size();
- size_t nsamps_available =
- _io_impl->packet_handler_recv_state.size_of_copy_buffs / bytes_per_item;
- nsamps_to_copy = std::min(num_samps, nsamps_available);
- size_t bytes_to_copy = nsamps_to_copy * bytes_per_item;
-
- convert_otw_type_to_io_type(
- _io_impl->packet_handler_recv_state.copy_buffs[0],
- _rx_otw_type,
- reinterpret_cast<boost::uint8_t *>(buffs[0]) + sent_samps * io_type.size,
- io_type,
- nsamps_to_copy);
-
- _io_impl->packet_handler_recv_state.copy_buffs[0] += bytes_to_copy;
- _io_impl->packet_handler_recv_state.size_of_copy_buffs -= bytes_to_copy;
-
- sent_samps += nsamps_to_copy;
-
- //check for overruns
- if (!(_io_impl->count++ % 10000)) {
- unsigned char overrun;
- int ret = _ctrl_transport->usrp_control_read(
- VRQ_GET_STATUS,
- 0,
- GS_RX_OVERRUN,
- &overrun, sizeof(char));
- if (ret < 0)
- std::cerr << "error: overrun check failed" << std::endl;
- if (overrun)
- std::cerr << "O" << std::endl;
- }
+ size_t total_samps_recv = 0;
+
+ while (total_samps_recv < num_samps) {
+
+ if (!_io_impl->get_recv_buffer(_data_transport))
+ return 0;
+
+ total_samps_recv += _io_impl->copy_convert_recv_samps(buffs[0],
+ num_samps,
+ total_samps_recv,
+ io_type,
+ _rx_otw_type);
+ _io_impl->check_overrun(_ctrl_transport,
+ _rx_samps_per_poll_interval, false);
}
- return sent_samps;
+
+ return total_samps_recv;
}
diff --git a/host/lib/usrp/usrp1/mboard_impl.cpp b/host/lib/usrp/usrp1/mboard_impl.cpp
index c3343f1f8..74ec514ff 100644
--- a/host/lib/usrp/usrp1/mboard_impl.cpp
+++ b/host/lib/usrp/usrp1/mboard_impl.cpp
@@ -114,7 +114,7 @@ static boost::uint32_t calc_tx_mux(
//calculate the channel flags
int channel_flags = 0, chan = 0;
BOOST_FOREACH(const subdev_spec_pair_t &pair, subdev_spec){
- wax::obj dboard = mboard[named_prop_t(MBOARD_PROP_RX_DBOARD, pair.db_name)];
+ wax::obj dboard = mboard[named_prop_t(MBOARD_PROP_TX_DBOARD, pair.db_name)];
wax::obj subdev = dboard[named_prop_t(DBOARD_PROP_SUBDEV, pair.sd_name)];
subdev_conn_t conn = subdev[SUBDEV_PROP_CONNECTION].as<subdev_conn_t>();
@@ -298,7 +298,7 @@ void usrp1_impl::mboard_set(const wax::obj &key, const wax::obj &val)
case MBOARD_PROP_RX_SUBDEV_SPEC:
_rx_subdev_spec = val.as<subdev_spec_t>();
- verify_rx_subdev_spec(_rx_subdev_spec, this->get_link());
+ verify_rx_subdev_spec(_rx_subdev_spec, _mboard_proxy->get_link());
//sanity check
UHD_ASSERT_THROW(_rx_subdev_spec.size() <= 2);
//set the mux and set the number of rx channels
@@ -307,7 +307,7 @@ void usrp1_impl::mboard_set(const wax::obj &key, const wax::obj &val)
case MBOARD_PROP_TX_SUBDEV_SPEC:
_tx_subdev_spec = val.as<subdev_spec_t>();
- verify_tx_subdev_spec(_tx_subdev_spec, this->get_link());
+ verify_tx_subdev_spec(_tx_subdev_spec, _mboard_proxy->get_link());
//sanity check
UHD_ASSERT_THROW(_tx_subdev_spec.size() <= 2);
//set the mux and set the number of tx channels
diff --git a/host/lib/usrp/usrp1/usrp1_iface.cpp b/host/lib/usrp/usrp1/usrp1_iface.cpp
index b175ba21f..9d326d6bd 100644
--- a/host/lib/usrp/usrp1/usrp1_iface.cpp
+++ b/host/lib/usrp/usrp1/usrp1_iface.cpp
@@ -53,7 +53,8 @@ public:
if (iface_debug) {
std::cout.fill('0');
- std::cout << "poke32(" << std::dec << addr << ", 0x";
+ std::cout << "poke32(";
+ std::cout << std::dec << std::setw(2) << addr << ", 0x";
std::cout << std::hex << std::setw(8) << value << ")" << std::endl;
}
@@ -129,11 +130,7 @@ public:
{
UHD_ASSERT_THROW(num_bytes < max_i2c_data_bytes);
- byte_vector_t out_bytes;
- byte_vector_t::iterator it = out_bytes.begin();
-
unsigned char buff[max_i2c_data_bytes];
-
int ret = _ctrl_transport->usrp_control_read(VRQ_I2C_READ,
addr & 0xff,
0,
@@ -142,9 +139,10 @@ public:
if ((ret < 0) || (unsigned)ret < (num_bytes)) {
std::cerr << "USRP: failed i2c read: " << ret << std::endl;
- return out_bytes;
+ return byte_vector_t(num_bytes, 0xff);
}
+ byte_vector_t out_bytes;
for (size_t i = 0; i < num_bytes; i++)
out_bytes.push_back(buff[i]);
@@ -168,7 +166,7 @@ public:
size_t num_bits,
bool readback)
{
- UHD_ASSERT_THROW((num_bits < 32) && !(num_bits % 8));
+ UHD_ASSERT_THROW((num_bits <= 32) && !(num_bits % 8));
size_t num_bytes = num_bits / 8;
// Byteswap on num_bytes
diff --git a/host/lib/usrp/usrp1/usrp1_impl.cpp b/host/lib/usrp/usrp1/usrp1_impl.cpp
index 33a069bc6..a15d0a244 100644
--- a/host/lib/usrp/usrp1/usrp1_impl.cpp
+++ b/host/lib/usrp/usrp1/usrp1_impl.cpp
@@ -55,13 +55,15 @@ static device_addrs_t usrp1_find(const device_addr_t &hint)
std::cout << "USRP1 firmware image: " << usrp1_fw_image << std::endl;
//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(usrp1_fw_image);
}
@@ -71,13 +73,15 @@ static device_addrs_t usrp1_find(const device_addr_t &hint)
boost::this_thread::sleep(boost::posix_time::milliseconds(500));
//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);
}
}
@@ -97,22 +101,23 @@ static device::sptr usrp1_make(const device_addr_t &device_addr)
std::cout << "USRP1 FPGA image: " << usrp1_fpga_image << 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(usrp1_fpga_image);
- 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
@@ -142,8 +147,12 @@ usrp1_impl::usrp1_impl(uhd::transport::usb_zero_copy::sptr data_transport,
_clock_ctrl = usrp1_clock_ctrl::make(_iface);
//create codec interface
- _codec_ctrls[DBOARD_SLOT_A] = usrp1_codec_ctrl::make(_iface, SPI_ENABLE_CODEC_A);
- _codec_ctrls[DBOARD_SLOT_B] = usrp1_codec_ctrl::make(_iface, SPI_ENABLE_CODEC_B);
+ _codec_ctrls[DBOARD_SLOT_A] = usrp1_codec_ctrl::make(
+ _iface, _clock_ctrl, SPI_ENABLE_CODEC_A
+ );
+ _codec_ctrls[DBOARD_SLOT_B] = usrp1_codec_ctrl::make(
+ _iface, _clock_ctrl, SPI_ENABLE_CODEC_B
+ );
//initialize the codecs
codec_init();
diff --git a/host/lib/usrp/usrp1/usrp1_impl.hpp b/host/lib/usrp/usrp1/usrp1_impl.hpp
index cbd3d5315..4b4ac51dd 100644
--- a/host/lib/usrp/usrp1/usrp1_impl.hpp
+++ b/host/lib/usrp/usrp1/usrp1_impl.hpp
@@ -120,6 +120,10 @@ private:
void issue_stream_cmd(const uhd::stream_cmd_t &stream_cmd);
void handle_overrun(size_t);
+ //underrun and overrun poll intervals
+ size_t _rx_samps_per_poll_interval;
+ size_t _tx_samps_per_poll_interval;
+
//otw types
uhd::otw_type_t _rx_otw_type;
uhd::otw_type_t _tx_otw_type;
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-16 22:01:17 +0000