From 6714ac0af376ab98f42f49e3f9fa2ceef359c109 Mon Sep 17 00:00:00 2001
From: Martin Braun <martin.braun@ettus.com>
Date: Thu, 17 Apr 2014 10:05:57 +0200
Subject: b200: Make the master clock rate auto-configurable

When no master_clock_rate is defined, the B200 driver will now
select a suitable clock rate automatically based on the selected
sampling rate.
The selected tick rate is a multiple of the LCM of tx and rx rates.

Auto-setting is done every time a streamer is generated or the sampling
rate is configured.
---
 host/lib/usrp/b200/b200_impl.cpp    |  32 +++++---
 host/lib/usrp/b200/b200_impl.hpp    |  58 ++++++++++++--
 host/lib/usrp/b200/b200_io_impl.cpp | 156 +++++++++++++++++++++++++++++++-----
 3 files changed, 210 insertions(+), 36 deletions(-)

(limited to 'host/lib/usrp/b200')

diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index da06e12b4..6d1172c98 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -416,6 +416,7 @@ b200_impl::b200_impl(const device_addr_t &device_addr)
         .publish(boost::bind(&b200_impl::get_tick_rate, this))
         .subscribe(boost::bind(&b200_impl::update_tick_rate, this, _1));
     _tree->create<time_spec_t>(mb_path / "time" / "cmd");
+    _tree->create<bool>(mb_path / "auto_tick_rate").set(false);
 
     ////////////////////////////////////////////////////////////////////
     // and do the misc mboard sensors
@@ -516,6 +517,11 @@ b200_impl::b200_impl(const device_addr_t &device_addr)
         _tree->access<double>(mb_path / "rx_dsps" / str(boost::format("%u") % i)/ "rate/value").set(B200_DEFAULT_RATE);
         _tree->access<double>(mb_path / "tx_dsps" / str(boost::format("%u") % i) / "rate/value").set(B200_DEFAULT_RATE);
     }
+    // We can automatically choose a master clock rate, but not if the user specifies one
+    _tree->access<bool>(mb_path / "auto_tick_rate").set(not device_addr.has_key("master_clock_rate"));
+    if (not device_addr.has_key("master_clock_rate")) {
+        UHD_MSG(status) << "Setting master clock rate selection to 'automatic'." << std::endl;
+    }
 
     //GPS installed: use external ref, time, and init time spec
     if (_gps and _gps->gps_detected())
@@ -579,7 +585,7 @@ void b200_impl::setup_radio(const size_t dspno)
     _tree->create<meta_range_t>(rx_dsp_path / "rate" / "range")
         .publish(boost::bind(&rx_dsp_core_3000::get_host_rates, perif.ddc));
     _tree->create<double>(rx_dsp_path / "rate" / "value")
-        .coerce(boost::bind(&rx_dsp_core_3000::set_host_rate, perif.ddc, _1))
+        .coerce(boost::bind(&b200_impl::coerce_rx_samp_rate, this, perif.ddc, dspno, _1))
         .subscribe(boost::bind(&b200_impl::update_rx_samp_rate, this, dspno, _1))
         .set(0.0); // Can only set this after tick rate is initialized.
     _tree->create<double>(rx_dsp_path / "freq" / "value")
@@ -603,7 +609,7 @@ void b200_impl::setup_radio(const size_t dspno)
     _tree->create<meta_range_t>(tx_dsp_path / "rate" / "range")
         .publish(boost::bind(&tx_dsp_core_3000::get_host_rates, perif.duc));
     _tree->create<double>(tx_dsp_path / "rate" / "value")
-        .coerce(boost::bind(&tx_dsp_core_3000::set_host_rate, perif.duc, _1))
+        .coerce(boost::bind(&b200_impl::coerce_tx_samp_rate, this, perif.duc, dspno, _1))
         .subscribe(boost::bind(&b200_impl::update_tx_samp_rate, this, dspno, _1))
         .set(0.0); // Can only set this after tick rate is initialized.
     _tree->create<double>(tx_dsp_path / "freq" / "value")
@@ -719,7 +725,7 @@ void b200_impl::codec_loopback_self_test(wb_iface::sptr iface)
 /***********************************************************************
  * Sample and tick rate comprehension below
  **********************************************************************/
-void b200_impl::enforce_tick_rate_limits(size_t chan_count, double tick_rate, const char* direction /*= NULL*/)
+void b200_impl::enforce_tick_rate_limits(size_t chan_count, double tick_rate, const std::string &direction /*= ""*/)
 {
     const size_t max_chans = 2;
     if (chan_count > max_chans)
@@ -727,7 +733,7 @@ void b200_impl::enforce_tick_rate_limits(size_t chan_count, double tick_rate, co
         throw uhd::value_error(boost::str(
             boost::format("cannot not setup %d %s channels (maximum is %d)")
                 % chan_count
-                % (direction ? direction : "data")
+                % (direction.empty() ? "data" : direction)
                 % max_chans
         ));
     }
@@ -741,20 +747,26 @@ void b200_impl::enforce_tick_rate_limits(size_t chan_count, double tick_rate, co
                     % (tick_rate/1e6)
                     % (max_tick_rate/1e6)
                     % chan_count
-                    % (direction ? direction : "data")
+                    % (direction.empty() ? "data" : direction)
             ));
         }
     }
 }
 
-double b200_impl::set_tick_rate(const double rate)
+double b200_impl::set_tick_rate(const double new_tick_rate)
 {
-    UHD_MSG(status) << (boost::format("Asking for clock rate %.6f MHz\n") % (rate/1e6));
+    UHD_MSG(status) << (boost::format("Asking for clock rate %.6f MHz... ") % (new_tick_rate/1e6)) << std::flush;
+    check_tick_rate_with_current_streamers(new_tick_rate);   // Defined in b200_io_impl.cpp
 
-    check_tick_rate_with_current_streamers(rate);   // Defined in b200_io_impl.cpp
+    // Make sure the clock rate is actually changed before doing
+    // the full Monty of setting regs and loopback tests etc.
+    if (std::abs(new_tick_rate - _tick_rate) < 1.0) {
+        UHD_MSG(status) << "OK" << std::endl;
+        return _tick_rate;
+    }
 
-    _tick_rate = _codec_ctrl->set_clock_rate(rate);
-    UHD_MSG(status) << (boost::format("Actually got clock rate %.6f MHz\n") % (_tick_rate/1e6));
+    _tick_rate = _codec_ctrl->set_clock_rate(new_tick_rate);
+    UHD_MSG(status) << std::endl << (boost::format("Actually got clock rate %.6f MHz.") % (_tick_rate/1e6)) << std::endl;
 
     //reset after clock rate change
     this->reset_codec_dcm();
diff --git a/host/lib/usrp/b200/b200_impl.hpp b/host/lib/usrp/b200/b200_impl.hpp
index 613844ffc..8e23ea6a0 100644
--- a/host/lib/usrp/b200/b200_impl.hpp
+++ b/host/lib/usrp/b200/b200_impl.hpp
@@ -98,7 +98,13 @@ public:
     uhd::rx_streamer::sptr get_rx_stream(const uhd::stream_args_t &args);
     uhd::tx_streamer::sptr get_tx_stream(const uhd::stream_args_t &args);
     bool recv_async_msg(uhd::async_metadata_t &, double);
-    void check_streamer_args(const uhd::stream_args_t &args, double tick_rate, const char* direction = NULL);
+
+    //! Check that the combination of stream args and tick rate are valid.
+    //
+    // Basically figures out the arguments for enforce_tick_rate_limits()
+    // and calls said method. If arguments are invalid, throws a
+    // uhd::value_error.
+    void check_streamer_args(const uhd::stream_args_t &args, double tick_rate, const std::string &direction = "");
 
 private:
     //controllers
@@ -114,9 +120,6 @@ private:
     uhd::transport::zero_copy_if::sptr _ctrl_transport;
     uhd::usrp::recv_packet_demuxer_3000::sptr _demux;
 
-    boost::weak_ptr<uhd::rx_streamer> _rx_streamer;
-    boost::weak_ptr<uhd::tx_streamer> _tx_streamer;
-
     //async ctrl + msgs
     uhd::msg_task::sptr _async_task;
     typedef uhd::transport::bounded_buffer<uhd::async_metadata_t> async_md_type;
@@ -188,11 +191,56 @@ private:
     double _tick_rate;
     double get_tick_rate(void){return _tick_rate;}
     double set_tick_rate(const double rate);
+
+    /*! \brief Choose a tick rate (master clock rate) that works well for the given sampling rate.
+     *
+     * This function will try and choose a master clock rate automatically.
+     * See the function definition for details on the algorithm.
+     *
+     * The chosen tick rate is the largest multiple of two that is smaler
+     * than the max tick rate.
+     * The base rate is either given explicitly, or is the lcm() of the tx
+     * and rx sampling rates. In that case, it reads the rates directly
+     * from the property tree. It also tries to guess the number of channels
+     * (for the max possible tick rate) by checking the available streamers.
+     * This value, too, can explicitly be given.
+     *
+     * \param rate If this is given, it will be used as a minimum rate, or
+     *             argument to lcm().
+     * \param tree_dsp_path The sampling rate from this property tree path
+     *                      will be ignored.
+     * \param num_chans If given, specifies the number of channels.
+     */
+    void set_auto_tick_rate(
+            const double rate=0,
+            const uhd::fs_path &tree_dsp_path="",
+            size_t num_chans=0
+    );
+
     void update_tick_rate(const double);
-    void enforce_tick_rate_limits(size_t chan_count, double tick_rate, const char* direction = NULL);
+
+    /*! Check if \p tick_rate works with \p chan_count channels.
+     *
+     * Throws a uhd::value_error if not.
+     */
+    void enforce_tick_rate_limits(size_t chan_count, double tick_rate, const std::string  &direction = "");
     void check_tick_rate_with_current_streamers(double rate);
 
+    /*! Return the max number of channels on active rx_streamer or tx_streamer objects associated with this device.
+     *
+     * \param direction Set to "TX" to only check tx_streamers, "RX" to only check
+     *                  rx_streamers. Any other value will check if \e any active
+     *                  streamers are available.
+     * \return Return the number of tx streamers (direction=="TX"), the number of rx
+     *         streamers (direction=="RX") or the total number of streamers.
+     */
+    size_t max_chan_count(const std::string &direction="");
+
+    //! Coercer, attached to the "rate/value" property on the rx dsps.
+    double coerce_rx_samp_rate(rx_dsp_core_3000::sptr, size_t, const double);
     void update_rx_samp_rate(const size_t, const double);
+    //! Coercer, attached to the "rate/value" property on the tx dsps.
+    double coerce_tx_samp_rate(tx_dsp_core_3000::sptr, size_t, const double);
     void update_tx_samp_rate(const size_t, const double);
 };
 
diff --git a/host/lib/usrp/b200/b200_io_impl.cpp b/host/lib/usrp/b200/b200_io_impl.cpp
index 9f6d593fe..cb32c610a 100644
--- a/host/lib/usrp/b200/b200_io_impl.cpp
+++ b/host/lib/usrp/b200/b200_io_impl.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2012-2013 Ettus Research LLC
+// Copyright 2012-2014 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
@@ -21,8 +21,10 @@
 #include "../../transport/super_recv_packet_handler.hpp"
 #include "../../transport/super_send_packet_handler.hpp"
 #include "async_packet_handler.hpp"
+#include <uhd/utils/math.hpp>
 #include <boost/bind.hpp>
 #include <boost/make_shared.hpp>
+#include <boost/math/common_factor.hpp>
 #include <set>
 
 using namespace uhd;
@@ -34,30 +36,32 @@ using namespace uhd::transport;
  **********************************************************************/
 void b200_impl::check_tick_rate_with_current_streamers(double rate)
 {
-    size_t max_tx_chan_count = 0, max_rx_chan_count = 0;
+    // Defined in b200_impl.cpp
+    enforce_tick_rate_limits(max_chan_count("RX"), rate, "RX");
+    enforce_tick_rate_limits(max_chan_count("TX"), rate, "TX");
+}
+
+// direction can either be "TX", "RX", or empty (default)
+size_t b200_impl::max_chan_count(const std::string &direction /* = "" */)
+{
+    size_t max_count = 0;
     BOOST_FOREACH(radio_perifs_t &perif, _radio_perifs)
     {
-        {
+        if ((direction == "RX" or direction.empty()) and not perif.rx_streamer.expired()) {
             boost::shared_ptr<sph::recv_packet_streamer> rx_streamer =
                 boost::dynamic_pointer_cast<sph::recv_packet_streamer>(perif.rx_streamer.lock());
-            if (rx_streamer)
-                max_rx_chan_count = std::max(max_rx_chan_count, rx_streamer->get_num_channels());
+            max_count = std::max(max_count, rx_streamer->get_num_channels());
         }
-
-        {
+        if ((direction == "TX" or direction.empty()) and not perif.tx_streamer.expired()) {
             boost::shared_ptr<sph::send_packet_streamer> tx_streamer =
                 boost::dynamic_pointer_cast<sph::send_packet_streamer>(perif.tx_streamer.lock());
-            if (tx_streamer)
-                max_tx_chan_count = std::max(max_tx_chan_count, tx_streamer->get_num_channels());
+            max_count = std::max(max_count, tx_streamer->get_num_channels());
         }
     }
-
-    // Defined in b200_impl.cpp
-    enforce_tick_rate_limits(max_rx_chan_count, rate, "RX");
-    enforce_tick_rate_limits(max_tx_chan_count, rate, "TX");
+    return max_count;
 }
 
-void b200_impl::check_streamer_args(const uhd::stream_args_t &args, double tick_rate, const char* direction /*= NULL*/)
+void b200_impl::check_streamer_args(const uhd::stream_args_t &args, double tick_rate, const std::string &direction /*= ""*/)
 {
     std::set<size_t> chans_set;
     for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++)
@@ -69,26 +73,120 @@ void b200_impl::check_streamer_args(const uhd::stream_args_t &args, double tick_
     enforce_tick_rate_limits(chans_set.size(), tick_rate, direction);   // Defined in b200_impl.cpp
 }
 
-void b200_impl::update_tick_rate(const double rate)
+void b200_impl::set_auto_tick_rate(
+        const double rate,
+        const fs_path &tree_dsp_path,
+        size_t num_chans
+) {
+    if (num_chans == 0) { // Divine them
+        num_chans = std::max(size_t(1), max_chan_count());
+    }
+
+    // See also the doxygen documentation for these steps in b200_impl.hpp
+    // Step 1: Obtain LCM and max rate from all relevant dsps
+    boost::uint32_t lcm_rate = (rate == 0) ? 1 : static_cast<boost::uint32_t>(floor(rate + 0.5));
+    for (int i = 0; i < 2; i++) { // Loop through rx and tx
+        std::string dir = (i == 0) ? "tx" : "rx";
+        // We have no way of knowing which DSPs are used, so we check them all.
+        BOOST_FOREACH(const std::string &dsp_no, _tree->list(str(boost::format("/mboards/0/%s_dsps") % dir))) {
+            fs_path dsp_path = str(boost::format("/mboards/0/%s_dsps/%s") % dir % dsp_no);
+            if (dsp_path == tree_dsp_path) {
+                continue;
+            }
+            double this_dsp_rate = _tree->access<double>(dsp_path / "rate/value").get();
+            // If this_dsp_rate == B200_DEFAULT_RATE, we assume the user did not actually set
+            // the sampling rate. If the user *did* set the rate to
+            // B200_DEFAULT_RATE on all DSPs, then this will still work (see below).
+            // If the user set one DSP to B200_DEFAULT_RATE and the other to
+            // a different rate, this also works if the rates are integer multiples
+            // of one another. Only for certain configurations of B200_DEFAULT_RATE
+            // and another rate that is not an integer multiple, this will be problematic.
+            // Since this case is less common than the case where a rate is left unset,
+            // we don't handle that but rather explain that corner case in the documentation.
+            if (this_dsp_rate == B200_DEFAULT_RATE) {
+                continue;
+            }
+            lcm_rate = boost::math::lcm<boost::uint32_t>(
+                    lcm_rate,
+                    static_cast<boost::uint32_t>(floor(this_dsp_rate + 0.5))
+            );
+        }
+    }
+    if (lcm_rate == 1) {
+        lcm_rate = static_cast<boost::uint32_t>(B200_DEFAULT_RATE);
+    }
+
+    // Step 2: Determine whether if we can use lcm_rate (preferred),
+    // or have to give up because too large:
+    const double max_tick_rate =
+        ((num_chans <= 1) ? ad9361_device_t::AD9361_RECOMMENDED_MAX_CLOCK_RATE : ad9361_device_t::AD9361_MAX_CLOCK_RATE/2);
+    double base_rate = static_cast<double>(lcm_rate);
+    if (base_rate > max_tick_rate) {
+        UHD_MSG(warning)
+            << "Cannot automatically determine an appropriate tick rate for these sampling rates." << std::endl
+            << "Consider using different sampling rates, or manually specify a suitable master clock rate." << std::endl;
+        return; // Let the others handle this
+    }
+
+    // Step 3: Choose the new rate
+    // Rules for choosing the tick rate:
+    // Choose a rate that is a power of 2 larger than the sampling rate,
+    // but at least 4. Cannot exceed the max tick rate, of course, but must
+    // be larger than the minimum tick rate.
+    // An equation that does all that is:
+    //
+    // f_auto = r * 2^floor(log2(f_max/r))
+    //
+    // where r is the base rate and f_max is the maximum tick rate. The case
+    // where floor() yields 1 must be caught.
+    const double min_tick_rate = _codec_ctrl->get_clock_rate_range().start();
+    // We use shifts here instead of 2^x because exp2() is not available in all compilers,
+    // also this guarantees no rounding issues. The type cast to int32_t serves as floor():
+    boost::int32_t multiplier = (1 << boost::int32_t(uhd::math::log2(max_tick_rate / base_rate)));
+    if (multiplier == 2 and base_rate >= min_tick_rate) {
+        // Don't bother (see above)
+        multiplier = 1;
+    }
+    double new_rate = base_rate * multiplier;
+    UHD_ASSERT_THROW(new_rate >= min_tick_rate);
+    UHD_ASSERT_THROW(new_rate <= max_tick_rate);
+
+    if (_tree->access<double>("/mboards/0/tick_rate").get() != new_rate) {
+        _tree->access<double>("/mboards/0/tick_rate").set(new_rate);
+    }
+}
+
+void b200_impl::update_tick_rate(const double new_tick_rate)
 {
-    check_tick_rate_with_current_streamers(rate);
+    check_tick_rate_with_current_streamers(new_tick_rate);
 
     BOOST_FOREACH(radio_perifs_t &perif, _radio_perifs)
     {
         boost::shared_ptr<sph::recv_packet_streamer> my_streamer =
             boost::dynamic_pointer_cast<sph::recv_packet_streamer>(perif.rx_streamer.lock());
-        if (my_streamer) my_streamer->set_tick_rate(rate);
-        perif.framer->set_tick_rate(_tick_rate);
+        if (my_streamer) my_streamer->set_tick_rate(new_tick_rate);
+        perif.framer->set_tick_rate(new_tick_rate);
     }
     BOOST_FOREACH(radio_perifs_t &perif, _radio_perifs)
     {
         boost::shared_ptr<sph::send_packet_streamer> my_streamer =
             boost::dynamic_pointer_cast<sph::send_packet_streamer>(perif.tx_streamer.lock());
-        if (my_streamer) my_streamer->set_tick_rate(rate);
-        perif.deframer->set_tick_rate(_tick_rate);
+        if (my_streamer) my_streamer->set_tick_rate(new_tick_rate);
+        perif.deframer->set_tick_rate(new_tick_rate);
     }
 }
 
+
+double b200_impl::coerce_rx_samp_rate(rx_dsp_core_3000::sptr ddc, size_t dspno, const double rx_rate)
+{
+    // Have to set tick rate first, or the ddc will change the requested rate based on default tick rate
+    if (_tree->access<bool>("/mboards/0/auto_tick_rate").get()) {
+        const std::string dsp_path = (boost::format("/mboards/0/rx_dsps/%s") % dspno).str();
+        set_auto_tick_rate(rx_rate, dsp_path);
+    }
+    return ddc->set_host_rate(rx_rate);
+}
+
 void b200_impl::update_rx_samp_rate(const size_t dspno, const double rate)
 {
     boost::shared_ptr<sph::recv_packet_streamer> my_streamer =
@@ -99,6 +197,16 @@ void b200_impl::update_rx_samp_rate(const size_t dspno, const double rate)
     my_streamer->set_scale_factor(adj);
 }
 
+double b200_impl::coerce_tx_samp_rate(tx_dsp_core_3000::sptr duc, size_t dspno, const double tx_rate)
+{
+    // Have to set tick rate first, or the duc will change the requested rate based on default tick rate
+    if (_tree->access<bool>("/mboards/0/auto_tick_rate").get()) {
+        const std::string dsp_path = (boost::format("/mboards/0/tx_dsps/%s") % dspno).str();
+        set_auto_tick_rate(tx_rate, dsp_path);
+    }
+    return duc->set_host_rate(tx_rate);
+}
+
 void b200_impl::update_tx_samp_rate(const size_t dspno, const double rate)
 {
     boost::shared_ptr<sph::send_packet_streamer> my_streamer =
@@ -262,6 +370,9 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t &args_)
     if (args.otw_format.empty()) args.otw_format = "sc16";
     args.channels = args.channels.empty()? std::vector<size_t>(1, 0) : args.channels;
 
+    if (_tree->access<bool>("/mboards/0/auto_tick_rate").get()) {
+        set_auto_tick_rate(0, "", args.channels.size());
+    }
     check_streamer_args(args, this->get_tick_rate(), "RX");
 
     boost::shared_ptr<sph::recv_packet_streamer> my_streamer;
@@ -367,7 +478,10 @@ tx_streamer::sptr b200_impl::get_tx_stream(const uhd::stream_args_t &args_)
     if (args.otw_format.empty()) args.otw_format = "sc16";
     args.channels = args.channels.empty()? std::vector<size_t>(1, 0) : args.channels;
 
-    check_streamer_args(args, this->get_tick_rate(), "TX");
+    if (_tree->access<bool>("/mboards/0/auto_tick_rate").get()) {
+        set_auto_tick_rate(0, "", args.channels.size());
+    }
+    check_streamer_args(args, this->get_tick_rate(), "RX");
 
     boost::shared_ptr<sph::send_packet_streamer> my_streamer;
     for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++)
-- 
cgit v1.2.3


From beabf3d302a98a0a1e28ae8cc4d338f0bd13db6e Mon Sep 17 00:00:00 2001
From: Ben Hilburn <ben.hilburn@ettus.com>
Date: Mon, 3 Nov 2014 17:05:26 -0800
Subject: uhd: replaced the `images_error` with a generic utility error

- Deleted images.*, moved functionality to paths.*
- Applies for all devices that check FPGA or FW compat numbers
- Adds generic utility search tool
---
 host/include/uhd/utils/CMakeLists.txt            |  1 -
 host/include/uhd/utils/images.hpp                | 53 -----------------------
 host/include/uhd/utils/paths.hpp                 | 25 +++++++++++
 host/lib/usrp/b100/b100_impl.cpp                 | 10 ++---
 host/lib/usrp/b100/b100_impl.hpp                 |  2 +-
 host/lib/usrp/b200/b200_impl.cpp                 | 15 +++----
 host/lib/usrp/b200/b200_impl.hpp                 |  6 +--
 host/lib/usrp/e100/e100_impl.cpp                 |  4 +-
 host/lib/usrp/e300/e300_impl.cpp                 |  4 +-
 host/lib/usrp/e300/e300_network.cpp              |  2 +-
 host/lib/usrp/usrp1/usrp1_impl.cpp               |  4 +-
 host/lib/usrp/usrp2/usrp2_iface.cpp              |  8 ++--
 host/lib/usrp/x300/x300_impl.cpp                 | 14 +++---
 host/lib/usrp_clock/octoclock/octoclock_impl.cpp |  6 +--
 host/lib/utils/CMakeLists.txt                    |  1 -
 host/lib/utils/images.cpp                        | 54 ------------------------
 host/lib/utils/paths.cpp                         | 37 ++++++++++++++--
 host/utils/b2xx_fx3_utils.cpp                    |  2 +-
 host/utils/octoclock_firmware_burner.cpp         |  2 +-
 host/utils/usrp_n2xx_simple_net_burner.cpp       |  2 +-
 host/utils/usrp_x3xx_fpga_burner.cpp             |  2 +-
 21 files changed, 99 insertions(+), 155 deletions(-)
 delete mode 100644 host/include/uhd/utils/images.hpp
 delete mode 100644 host/lib/utils/images.cpp

(limited to 'host/lib/usrp/b200')

diff --git a/host/include/uhd/utils/CMakeLists.txt b/host/include/uhd/utils/CMakeLists.txt
index c308c9cde..05f6892d2 100644
--- a/host/include/uhd/utils/CMakeLists.txt
+++ b/host/include/uhd/utils/CMakeLists.txt
@@ -25,7 +25,6 @@ UHD_INSTALL(FILES
     cast.hpp
     csv.hpp
     gain_group.hpp
-    images.hpp
     log.hpp
     math.hpp
     msg.hpp
diff --git a/host/include/uhd/utils/images.hpp b/host/include/uhd/utils/images.hpp
deleted file mode 100644
index a0934fb08..000000000
--- a/host/include/uhd/utils/images.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// Copyright 2010,2012 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_UHD_UTILS_IMAGES_HPP
-#define INCLUDED_UHD_UTILS_IMAGES_HPP
-
-#include <uhd/config.hpp>
-#include <string>
-
-namespace uhd{
-
-    /*!
-     * Search for an image in the system image paths:
-     * Search compiled-in paths and environment variable paths
-     * for a specific image file with the provided file name.
-     * \param image_name the name of the file
-     * \return the full system path to the file
-     * \throw exception if the image was not found
-     */
-    UHD_API std::string find_image_path(const std::string &image_name);
-
-    /*!
-     * Search for the location of the UHD Images Downloader script.
-     * \return the full system path to uhd_images_downloader.py
-     */
-
-    UHD_API std::string find_images_downloader(void);
-
-    /*!
-     * Return the error string for recommending using the UHD Images Downloader.
-     * String depends on OS.
-     * \return the message suggesting the use of uhd_images_downloader.py
-     */
-
-    UHD_API std::string print_images_error(void);
-
-} //namespace uhd
-
-#endif /* INCLUDED_UHD_UTILS_IMAGES_HPP */
diff --git a/host/include/uhd/utils/paths.hpp b/host/include/uhd/utils/paths.hpp
index e0f455e92..c1f32ba61 100644
--- a/host/include/uhd/utils/paths.hpp
+++ b/host/include/uhd/utils/paths.hpp
@@ -32,6 +32,31 @@ namespace uhd{
     //! Get a string representing the system's pkg directory
     UHD_API std::string get_pkg_path(void);
 
+    /*!
+     * Search for an image in the system image paths:
+     * Search compiled-in paths and environment variable paths
+     * for a specific image file with the provided file name.
+     * \param image_name the name of the file
+     * \return the full system path to the file
+     * \throw exception if the image was not found
+     */
+    UHD_API std::string find_image_path(const std::string &image_name);
+
+    /*!
+     * Search for the location of a particular UHD utility.
+     * The utility must be installed in the `uhd/utils` directory.
+     * \param the name of the utility to search for
+     * \return the full system path to @param
+     */
+    UHD_API std::string find_utility(std::string name);
+
+    /*!
+     * Return an error string recommending the user run the utility.
+     * The error string will include the full path to the utility to run.
+     * \return the message suggesting the use of the named utility.
+     */
+    UHD_API std::string print_utility_error(std::string name);
+
 } //namespace uhd
 
 #endif /* INCLUDED_UHD_UTILS_PATHS_HPP */
diff --git a/host/lib/usrp/b100/b100_impl.cpp b/host/lib/usrp/b100/b100_impl.cpp
index 24a87a3c8..c4279913c 100644
--- a/host/lib/usrp/b100/b100_impl.cpp
+++ b/host/lib/usrp/b100/b100_impl.cpp
@@ -23,7 +23,7 @@
 #include <uhd/utils/cast.hpp>
 #include <uhd/exception.hpp>
 #include <uhd/utils/static.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <uhd/utils/safe_call.hpp>
 #include <boost/format.hpp>
 #include <boost/assign/list_of.hpp>
@@ -82,7 +82,7 @@ static device_addrs_t b100_find(const device_addr_t &hint)
             b100_fw_image = find_image_path(hint.get("fw", B100_FW_FILE_NAME));
         }
         catch(...){
-            UHD_MSG(warning) << boost::format("Could not locate B100 firmware. %s\n") % print_images_error();
+            UHD_MSG(warning) << boost::format("Could not locate B100 firmware. %s\n") % print_utility_error("uhd_images_downloader.py");
             return b100_addrs;
         }
         UHD_LOG << "the firmware image: " << b100_fw_image << std::endl;
@@ -532,10 +532,10 @@ void b100_impl::check_fw_compat(void){
     );
     if (fw_compat_num != B100_FW_COMPAT_NUM){
         throw uhd::runtime_error(str(boost::format(
-            "Expected firmware compatibility number 0x%x, but got 0x%x:\n"
+            "Expected firmware compatibility number %d, but got %d:\n"
             "The firmware build is not compatible with the host code build.\n"
             "%s"
-        ) % B100_FW_COMPAT_NUM % fw_compat_num % print_images_error()));
+        ) % int(B100_FW_COMPAT_NUM) % fw_compat_num % print_utility_error("uhd_images_downloader.py")));
     }
     _tree->create<std::string>("/mboards/0/fw_version").set(str(boost::format("%u.0") % fw_compat_num));
 }
@@ -552,7 +552,7 @@ void b100_impl::check_fpga_compat(void){
             "Expected FPGA compatibility number %d, but got %d:\n"
             "The FPGA build is not compatible with the host code build."
             "%s"
-        ) % int(B100_FPGA_COMPAT_NUM) % fpga_major % print_images_error()));
+        ) % int(B100_FPGA_COMPAT_NUM) % fpga_major % print_utility_error("uhd_images_downloader.py")));
     }
     _tree->create<std::string>("/mboards/0/fpga_version").set(str(boost::format("%u.%u") % fpga_major % fpga_minor));
 }
diff --git a/host/lib/usrp/b100/b100_impl.hpp b/host/lib/usrp/b100/b100_impl.hpp
index 59ea2202e..dbca543be 100644
--- a/host/lib/usrp/b100/b100_impl.hpp
+++ b/host/lib/usrp/b100/b100_impl.hpp
@@ -46,7 +46,7 @@
 static const double          B100_LINK_RATE_BPS = 256e6/5; //pratical link rate (< 480 Mbps)
 static const std::string     B100_FW_FILE_NAME = "usrp_b100_fw.ihx";
 static const std::string     B100_FPGA_FILE_NAME = "usrp_b100_fpga.bin";
-static const boost::uint16_t B100_FW_COMPAT_NUM = 0x04;
+static const boost::uint16_t B100_FW_COMPAT_NUM = 4;
 static const boost::uint16_t B100_FPGA_COMPAT_NUM = 11;
 static const boost::uint32_t B100_RX_SID_BASE = 30;
 static const boost::uint32_t B100_TX_ASYNC_SID = 10;
diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index 6d1172c98..b3c190c50 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -22,7 +22,7 @@
 #include <uhd/utils/cast.hpp>
 #include <uhd/exception.hpp>
 #include <uhd/utils/static.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <uhd/utils/safe_call.hpp>
 #include <uhd/usrp/dboard_eeprom.hpp>
 #include <boost/format.hpp>
@@ -115,7 +115,7 @@ static device_addrs_t b200_find(const device_addr_t &hint)
             UHD_MSG(warning) << boost::format(
                 "Could not locate B200 firmware.\n"
                 "Please install the images package. %s\n"
-            ) % print_images_error();
+            ) % print_utility_error("uhd_images_downloader.py");
             return b200_addrs;
         }
         UHD_LOG << "the firmware image: " << b200_fw_image << std::endl;
@@ -791,11 +791,11 @@ void b200_impl::check_fw_compat(void)
 
     if (compat_major != B200_FW_COMPAT_NUM_MAJOR){
         throw uhd::runtime_error(str(boost::format(
-            "Expected firmware compatibility number 0x%x, but got 0x%x.%x:\n"
+            "Expected firmware compatibility number %d.%d, but got %d.%d:\n"
             "The firmware build is not compatible with the host code build.\n"
             "%s"
-        ) % int(B200_FW_COMPAT_NUM_MAJOR) % compat_major % compat_minor
-          % print_images_error()));
+        )   % int(B200_FW_COMPAT_NUM_MAJOR) % int(B200_FW_COMPAT_NUM_MINOR)
+            % compat_major % compat_minor % print_utility_error("uhd_images_downloader.py")));
     }
     _tree->create<std::string>("/mboards/0/fw_version").set(str(boost::format("%u.%u")
                 % compat_major % compat_minor));
@@ -812,11 +812,10 @@ void b200_impl::check_fpga_compat(void)
 
     if (compat_major != B200_FPGA_COMPAT_NUM){
         throw uhd::runtime_error(str(boost::format(
-            "Expected FPGA compatibility number 0x%x, but got 0x%x.%x:\n"
+            "Expected FPGA compatibility number %d, but got %d:\n"
             "The FPGA build is not compatible with the host code build.\n"
             "%s"
-        ) % int(B200_FPGA_COMPAT_NUM) % compat_major % compat_minor
-          % print_images_error()));
+        ) % int(B200_FPGA_COMPAT_NUM) % compat_major % print_utility_error("uhd_images_downloader.py")));
     }
     _tree->create<std::string>("/mboards/0/fpga_version").set(str(boost::format("%u.%u")
                 % compat_major % compat_minor));
diff --git a/host/lib/usrp/b200/b200_impl.hpp b/host/lib/usrp/b200/b200_impl.hpp
index 22e962bd5..71592f60b 100644
--- a/host/lib/usrp/b200/b200_impl.hpp
+++ b/host/lib/usrp/b200/b200_impl.hpp
@@ -45,9 +45,9 @@
 #include <uhd/transport/bounded_buffer.hpp>
 #include <boost/weak_ptr.hpp>
 #include "recv_packet_demuxer_3000.hpp"
-static const boost::uint8_t  B200_FW_COMPAT_NUM_MAJOR = 0x07;
-static const boost::uint8_t  B200_FW_COMPAT_NUM_MINOR = 0x00;
-static const boost::uint16_t B200_FPGA_COMPAT_NUM = 0x04;
+static const boost::uint8_t  B200_FW_COMPAT_NUM_MAJOR = 7;
+static const boost::uint8_t  B200_FW_COMPAT_NUM_MINOR = 0;
+static const boost::uint16_t B200_FPGA_COMPAT_NUM = 4;
 static const double          B200_BUS_CLOCK_RATE = 100e6;
 static const double          B200_DEFAULT_TICK_RATE = 32e6;
 static const double          B200_DEFAULT_FREQ = 100e6; // Hz
diff --git a/host/lib/usrp/e100/e100_impl.cpp b/host/lib/usrp/e100/e100_impl.cpp
index 8b4f2316c..ac419e0e0 100644
--- a/host/lib/usrp/e100/e100_impl.cpp
+++ b/host/lib/usrp/e100/e100_impl.cpp
@@ -21,7 +21,7 @@
 #include <uhd/utils/msg.hpp>
 #include <uhd/exception.hpp>
 #include <uhd/utils/static.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <boost/bind.hpp>
 #include <boost/format.hpp>
 #include <boost/filesystem.hpp>
@@ -132,7 +132,7 @@ e100_impl::e100_impl(const uhd::device_addr_t &device_addr){
         e100_fpga_image = find_image_path(device_addr.get("fpga", default_fpga_file_name));
     }
     catch(...){
-        UHD_MSG(error) << boost::format("Could not find FPGA image. %s\n") % print_images_error();
+        UHD_MSG(error) << boost::format("Could not find FPGA image. %s\n") % print_utility_error("uhd_images_downloader.py");
         throw;
     }
     e100_load_fpga(e100_fpga_image);
diff --git a/host/lib/usrp/e300/e300_impl.cpp b/host/lib/usrp/e300/e300_impl.cpp
index e42ac390e..8807a56e4 100644
--- a/host/lib/usrp/e300/e300_impl.cpp
+++ b/host/lib/usrp/e300/e300_impl.cpp
@@ -28,7 +28,7 @@
 #include <uhd/utils/msg.hpp>
 #include <uhd/utils/log.hpp>
 #include <uhd/utils/static.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <uhd/usrp/dboard_eeprom.hpp>
 #include <uhd/transport/if_addrs.hpp>
 #include <uhd/transport/udp_zero_copy.hpp>
@@ -397,7 +397,7 @@ e300_impl::e300_impl(const uhd::device_addr_t &device_addr)
             "%s"
         ) % fpga::COMPAT_MAJOR
           % _get_version(FPGA_MAJOR) % _get_version(FPGA_MINOR)
-          % print_images_error()));
+          % print_utility_error("uhd_images_downloader.py")));
     }
 
     ////////////////////////////////////////////////////////////////////
diff --git a/host/lib/usrp/e300/e300_network.cpp b/host/lib/usrp/e300/e300_network.cpp
index 883ff0c4f..59e1eec86 100644
--- a/host/lib/usrp/e300/e300_network.cpp
+++ b/host/lib/usrp/e300/e300_network.cpp
@@ -33,7 +33,7 @@
 
 #include <uhd/utils/msg.hpp>
 #include <uhd/utils/byteswap.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 
 #include <boost/asio.hpp>
 #include <boost/thread.hpp>
diff --git a/host/lib/usrp/usrp1/usrp1_impl.cpp b/host/lib/usrp/usrp1/usrp1_impl.cpp
index 709092e42..dbd5408e8 100644
--- a/host/lib/usrp/usrp1/usrp1_impl.cpp
+++ b/host/lib/usrp/usrp1/usrp1_impl.cpp
@@ -23,7 +23,7 @@
 #include <uhd/utils/cast.hpp>
 #include <uhd/exception.hpp>
 #include <uhd/utils/static.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <boost/format.hpp>
 #include <boost/assign/list_of.hpp>
 #include <boost/filesystem.hpp>
@@ -85,7 +85,7 @@ static device_addrs_t usrp1_find(const device_addr_t &hint)
             usrp1_fw_image = find_image_path(hint.get("fw", "usrp1_fw.ihx"));
         }
         catch(...){
-            UHD_MSG(warning) << boost::format("Could not locate USRP1 firmware. %s") % print_images_error();
+            UHD_MSG(warning) << boost::format("Could not locate USRP1 firmware. %s") % print_utility_error("uhd_images_downloader.py");
         }
         UHD_LOG << "USRP1 firmware image: " << usrp1_fw_image << std::endl;
 
diff --git a/host/lib/usrp/usrp2/usrp2_iface.cpp b/host/lib/usrp/usrp2/usrp2_iface.cpp
index b2085807f..65cf90a17 100644
--- a/host/lib/usrp/usrp2/usrp2_iface.cpp
+++ b/host/lib/usrp/usrp2/usrp2_iface.cpp
@@ -23,7 +23,7 @@
 #include <uhd/utils/msg.hpp>
 #include <uhd/utils/paths.hpp>
 #include <uhd/utils/tasks.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <uhd/utils/safe_call.hpp>
 #include <uhd/types/dict.hpp>
 #include <boost/thread.hpp>
@@ -375,7 +375,7 @@ public:
             fpga_image_path = uhd::find_image_path(fpga_image);
         }
         catch(const std::exception &){
-            return str(boost::format("Could not find %s and %s in your images path!\n%s") % fw_image % fpga_image % print_images_error());
+            return str(boost::format("Could not find %s and %s in your images path!\n%s") % fw_image % fpga_image % print_utility_error("uhd_images_downloader.py"));
         }
 
         //escape char for multi-line cmd + newline + indent?
@@ -389,13 +389,13 @@ public:
         if (this->get_rev() == USRP2_REV3 or this->get_rev() == USRP2_REV4){
             const std::string card_burner = (fs::path(uhd::get_pkg_path()) / UHD_LIB_DIR / "uhd" / "utils" / "usrp2_card_burner.py").string();
             const std::string card_burner_cmd = str(boost::format("\"%s%s\" %s--fpga=\"%s\" %s--fw=\"%s\"") % sudo % card_burner % ml % fpga_image_path % ml % fw_image_path);
-            return str(boost::format("%s\n%s") % print_images_error() % card_burner_cmd);
+            return str(boost::format("%s\n%s") % print_utility_error("uhd_images_downloader.py") % card_burner_cmd);
         }
         else{
             const std::string addr = _ctrl_transport->get_recv_addr();
             const std::string net_burner_path = (fs::path(uhd::get_pkg_path()) / UHD_LIB_DIR / "uhd" / "utils" / "usrp_n2xx_simple_net_burner").string();
             const std::string net_burner_cmd = str(boost::format("\"%s\" %s--addr=\"%s\"") % net_burner_path % ml % addr);
-            return str(boost::format("%s\n%s") % print_images_error() % net_burner_cmd);
+            return str(boost::format("%s\n%s") % print_utility_error("uhd_images_downloader.py") % net_burner_cmd);
         }
     }
 
diff --git a/host/lib/usrp/x300/x300_impl.cpp b/host/lib/usrp/x300/x300_impl.cpp
index a879ae02d..8d255097d 100644
--- a/host/lib/usrp/x300/x300_impl.cpp
+++ b/host/lib/usrp/x300/x300_impl.cpp
@@ -24,7 +24,7 @@
 #include "apply_corrections.hpp"
 #include <uhd/utils/static.hpp>
 #include <uhd/utils/msg.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <uhd/utils/safe_call.hpp>
 #include <uhd/usrp/subdev_spec.hpp>
 #include <uhd/transport/if_addrs.hpp>
@@ -171,7 +171,7 @@ static device_addrs_t x300_find_pcie(const device_addr_t &hint, bool explicit_qu
             default:
                 continue;
         }
-        
+
         niriok_proxy::sptr kernel_proxy = niriok_proxy::make_and_open(dev_info.interface_path);
 
         //Attempt to read the name from the EEPROM and perform filtering.
@@ -1670,11 +1670,11 @@ void x300_impl::check_fw_compat(const fs_path &mb_path, wb_iface::sptr iface)
     if (compat_major != X300_FW_COMPAT_MAJOR)
     {
         throw uhd::runtime_error(str(boost::format(
-            "Expected firmware compatibility number 0x%x, but got 0x%x.%x:\n"
+            "Expected firmware compatibility number %d.%d, but got %d.%d:\n"
             "The firmware build is not compatible with the host code build.\n"
             "%s"
-        ) % int(X300_FW_COMPAT_MAJOR) % compat_major % compat_minor
-          % print_images_error()));
+        )   % int(X300_FW_COMPAT_MAJOR) % int(X300_FW_COMPAT_MINOR)
+            % compat_major % compat_minor % print_utility_error("uhd_images_downloader.py")));
     }
     _tree->create<std::string>(mb_path / "fw_version").set(str(boost::format("%u.%u")
                 % compat_major % compat_minor));
@@ -1694,11 +1694,11 @@ void x300_impl::check_fpga_compat(const fs_path &mb_path, wb_iface::sptr iface)
             "Download the appropriate FPGA images for this version of UHD.\n"
             "%s\n\n"
             "Then burn a new image to the on-board flash storage of your\n"
-            "USRP X3xx device using the burner utility. \n\n"
+            "USRP X3xx device using the burner utility. %s\n\n"
             "For more information, refer to the UHD manual:\n\n"
             " http://files.ettus.com/manual/page_usrp_x3x0.html#x3x0_flash"
         )   % int(X300_FPGA_COMPAT_MAJOR) % compat_major
-            % print_images_error()));
+            % print_utility_error("uhd_images_downloader.py") % print_utility_error("usrp_x3xx_fpga_burner")));
     }
     _tree->create<std::string>(mb_path / "fpga_version").set(str(boost::format("%u.%u")
                 % compat_major % compat_minor));
diff --git a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
index 8c207dd9f..d55fab10e 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
@@ -33,7 +33,7 @@
 #include <uhd/usrp/gps_ctrl.hpp>
 #include <uhd/usrp_clock/octoclock_eeprom.hpp>
 #include <uhd/utils/byteswap.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <uhd/utils/msg.hpp>
 #include <uhd/utils/paths.hpp>
 #include <uhd/utils/static.hpp>
@@ -420,7 +420,7 @@ std::string octoclock_impl::_get_images_help_message(const std::string &addr){
     catch(const std::exception &e){
         return str(boost::format("Could not find %s in your images path.\n%s")
                    % image_name
-                   % uhd::print_images_error());
+                   % uhd::print_utility_error("uhd_images_downloader.py"));
     }
 
     //Get escape character
@@ -433,5 +433,5 @@ std::string octoclock_impl::_get_images_help_message(const std::string &addr){
     //Get burner command
     const std::string burner_path = (fs::path(uhd::get_pkg_path()) / "bin" / "octoclock_firmware_burner").string();
     const std::string burner_cmd = str(boost::format("%s %s--addr=\"%s\"") % burner_path % ml % addr);
-    return str(boost::format("%s\n%s") % uhd::print_images_error() % burner_cmd);
+    return str(boost::format("%s\n%s") % uhd::print_utility_error("uhd_images_downloader.py") % burner_cmd);
 }
diff --git a/host/lib/utils/CMakeLists.txt b/host/lib/utils/CMakeLists.txt
index 106e2b650..369920ac1 100644
--- a/host/lib/utils/CMakeLists.txt
+++ b/host/lib/utils/CMakeLists.txt
@@ -132,7 +132,6 @@ SET_SOURCE_FILES_PROPERTIES(
 LIBUHD_APPEND_SOURCES(
     ${CMAKE_CURRENT_SOURCE_DIR}/csv.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/gain_group.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/images.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/load_modules.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/log.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/msg.cpp
diff --git a/host/lib/utils/images.cpp b/host/lib/utils/images.cpp
deleted file mode 100644
index 1ba2f81e6..000000000
--- a/host/lib/utils/images.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// Copyright 2010-2012 Ettus Research LLC
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-#include <uhd/utils/images.hpp>
-#include <uhd/exception.hpp>
-#include <uhd/utils/paths.hpp>
-#include <boost/foreach.hpp>
-#include <boost/filesystem.hpp>
-#include <vector>
-#include <iostream>
-
-namespace fs = boost::filesystem;
-
-std::vector<fs::path> get_image_paths(void); //defined in paths.cpp
-
-/***********************************************************************
- * Find an image in the image paths
- **********************************************************************/
-std::string uhd::find_image_path(const std::string &image_name){
-    if (fs::exists(image_name)){
-        return fs::system_complete(image_name).string();
-    }
-    BOOST_FOREACH(const fs::path &path, get_image_paths()){
-        fs::path image_path = path / image_name;
-        if (fs::exists(image_path)) return image_path.string();
-    }
-    throw uhd::io_error("Could not find path for image: " + image_name + "\n\n" + uhd::print_images_error());
-}
-
-std::string uhd::find_images_downloader(void){
-    return fs::path(fs::path(uhd::get_pkg_path()) / UHD_LIB_DIR / "uhd" / "utils" / "uhd_images_downloader.py").string();
-}
-
-std::string uhd::print_images_error(void){
-    #ifdef UHD_PLATFORM_WIN32
-    return "As an Administrator, please run:\n\n\"" + find_images_downloader() + "\"";
-    #else
-    return "Please run:\n\nsudo \"" + find_images_downloader() + "\"";
-    #endif
-}
diff --git a/host/lib/utils/paths.cpp b/host/lib/utils/paths.cpp
index 3e2bea1c6..282ebb566 100644
--- a/host/lib/utils/paths.cpp
+++ b/host/lib/utils/paths.cpp
@@ -17,15 +17,19 @@
 
 #include <uhd/config.hpp>
 #include <uhd/utils/paths.hpp>
-#include <boost/tokenizer.hpp>
+
+#include <boost/bind.hpp>
+#include <uhd/exception.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/foreach.hpp>
-#include <boost/bind.hpp>
+#include <boost/tokenizer.hpp>
+
+#include <cstdio>  //P_tmpdir
 #include <cstdlib>
+#include <iostream>
 #include <string>
 #include <vector>
-#include <cstdlib> //getenv
-#include <cstdio>  //P_tmpdir
+
 #ifdef BOOST_MSVC
 #define USE_GET_TEMP_PATH
 #include <windows.h> //GetTempPath
@@ -136,3 +140,28 @@ std::string uhd::get_app_path(void){
 
     return uhd::get_tmp_path();
 }
+
+std::string uhd::find_image_path(const std::string &image_name){
+    if (fs::exists(image_name)){
+        return fs::system_complete(image_name).string();
+    }
+    BOOST_FOREACH(const fs::path &path, get_image_paths()){
+        fs::path image_path = path / image_name;
+        if (fs::exists(image_path)) return image_path.string();
+    }
+    throw uhd::io_error("Could not find path for image: " + image_name
+            + "\n\n" + uhd::print_utility_error("uhd_images_downloader.py"));
+}
+
+std::string uhd::find_utility(std::string name) {
+    return fs::path(fs::path(uhd::get_pkg_path()) / UHD_LIB_DIR / "uhd" / "utils" / name)
+        .string();
+}
+
+std::string uhd::print_utility_error(std::string name){
+    #ifdef UHD_PLATFORM_WIN32
+    return "As an Administrator, please run:\n\n\"" + find_utility(name) + "\"";
+    #else
+    return "Please run:\n\n \"" + find_utility(name) + "\"";
+    #endif
+}
diff --git a/host/utils/b2xx_fx3_utils.cpp b/host/utils/b2xx_fx3_utils.cpp
index 0cab6618d..8b64be63e 100644
--- a/host/utils/b2xx_fx3_utils.cpp
+++ b/host/utils/b2xx_fx3_utils.cpp
@@ -39,7 +39,7 @@
 #include <uhd/transport/usb_control.hpp>
 #include <uhd/transport/usb_device_handle.hpp>
 #include <uhd/exception.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 
 namespace po = boost::program_options;
 namespace fs = boost::filesystem;
diff --git a/host/utils/octoclock_firmware_burner.cpp b/host/utils/octoclock_firmware_burner.cpp
index 9551ddd20..0a48caabd 100644
--- a/host/utils/octoclock_firmware_burner.cpp
+++ b/host/utils/octoclock_firmware_burner.cpp
@@ -37,7 +37,7 @@
 #include <uhd/types/device_addr.hpp>
 #include <uhd/types/time_spec.hpp>
 #include <uhd/utils/byteswap.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <uhd/utils/paths.hpp>
 #include <uhd/utils/safe_main.hpp>
 
diff --git a/host/utils/usrp_n2xx_simple_net_burner.cpp b/host/utils/usrp_n2xx_simple_net_burner.cpp
index dc83b6fdf..b06e67bb2 100644
--- a/host/utils/usrp_n2xx_simple_net_burner.cpp
+++ b/host/utils/usrp_n2xx_simple_net_burner.cpp
@@ -38,7 +38,7 @@
 #include <uhd/transport/udp_simple.hpp>
 #include <uhd/types/dict.hpp>
 #include <uhd/utils/byteswap.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <uhd/utils/safe_main.hpp>
 #include <uhd/utils/safe_call.hpp>
 
diff --git a/host/utils/usrp_x3xx_fpga_burner.cpp b/host/utils/usrp_x3xx_fpga_burner.cpp
index b849cfb92..abd5815e8 100644
--- a/host/utils/usrp_x3xx_fpga_burner.cpp
+++ b/host/utils/usrp_x3xx_fpga_burner.cpp
@@ -45,7 +45,7 @@
 #include <uhd/device.hpp>
 #include <uhd/types/device_addr.hpp>
 #include <uhd/utils/byteswap.hpp>
-#include <uhd/utils/images.hpp>
+#include <uhd/utils/paths.hpp>
 #include <uhd/utils/safe_main.hpp>
 #include <uhd/utils/safe_call.hpp>
 
-- 
cgit v1.2.3


From 3c5fe0a201d78a8732aad31a71bf806e00c89db1 Mon Sep 17 00:00:00 2001
From: Ben Hilburn <ben.hilburn@ettus.com>
Date: Thu, 18 Dec 2014 15:37:20 -0800
Subject: Adding support for NI VID + PIDs for USRP B2xx devices.

---
 host/include/uhd/transport/usb_device_handle.hpp |  3 +
 host/lib/transport/libusb1_base.cpp              | 20 +++---
 host/lib/usrp/b200/b200_iface.hpp                |  3 +
 host/lib/usrp/b200/b200_impl.cpp                 | 72 +++++++++++++++++----
 host/utils/b2xx_fx3_utils.cpp                    | 80 ++++++++++++++++--------
 5 files changed, 134 insertions(+), 44 deletions(-)

(limited to 'host/lib/usrp/b200')

diff --git a/host/include/uhd/transport/usb_device_handle.hpp b/host/include/uhd/transport/usb_device_handle.hpp
index fdea9e2be..bf122f549 100644
--- a/host/include/uhd/transport/usb_device_handle.hpp
+++ b/host/include/uhd/transport/usb_device_handle.hpp
@@ -41,6 +41,7 @@ namespace uhd { namespace transport {
 class UHD_API usb_device_handle : boost::noncopyable {
 public:
     typedef boost::shared_ptr<usb_device_handle> sptr;
+    typedef std::pair<boost::uint16_t, boost::uint16_t> vid_pid_pair_t;
 
     /*!
      * Return the device's serial number
@@ -83,6 +84,8 @@ public:
      * \return a vector of USB device handles that match vid and pid
      */
     static std::vector<usb_device_handle::sptr> get_device_list(boost::uint16_t vid, boost::uint16_t pid);
+    static std::vector<usb_device_handle::sptr> get_device_list(const std::vector<usb_device_handle::vid_pid_pair_t>& vid_pid_pair_list);
+
 
 }; //namespace usb
 
diff --git a/host/lib/transport/libusb1_base.cpp b/host/lib/transport/libusb1_base.cpp
index ee4e20adb..18acb1fdc 100644
--- a/host/lib/transport/libusb1_base.cpp
+++ b/host/lib/transport/libusb1_base.cpp
@@ -343,15 +343,21 @@ libusb::special_handle::sptr libusb::special_handle::make(device::sptr dev){
 std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(
     boost::uint16_t vid, boost::uint16_t pid
 ){
-    std::vector<usb_device_handle::sptr> handles;
+    return usb_device_handle::get_device_list(std::vector<usb_device_handle::vid_pid_pair_t>(1,usb_device_handle::vid_pid_pair_t(vid,pid)));
+}
 
+std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(const std::vector<usb_device_handle::vid_pid_pair_t>& vid_pid_pair_list)
+{
+    std::vector<usb_device_handle::sptr> handles;
     libusb::device_list::sptr dev_list = libusb::device_list::make();
-    for (size_t i = 0; i < dev_list->size(); i++){
-        usb_device_handle::sptr handle = libusb::special_handle::make(dev_list->at(i));
-        if (handle->get_vendor_id() == vid and handle->get_product_id() == pid){
-            handles.push_back(handle);
-        }
+    for(size_t iter = 0; iter < vid_pid_pair_list.size(); ++iter)
+    {
+       for (size_t i = 0; i < dev_list->size(); i++){
+           usb_device_handle::sptr handle = libusb::special_handle::make(dev_list->at(i));
+           if (handle->get_vendor_id() == vid_pid_pair_list[iter].first and handle->get_product_id() == vid_pid_pair_list[iter].second){
+               handles.push_back(handle);
+           }
+       }
     }
-
     return handles;
 }
diff --git a/host/lib/usrp/b200/b200_iface.hpp b/host/lib/usrp/b200/b200_iface.hpp
index 83adfdd64..1821865d3 100644
--- a/host/lib/usrp/b200/b200_iface.hpp
+++ b/host/lib/usrp/b200/b200_iface.hpp
@@ -26,7 +26,10 @@
 #include "ad9361_ctrl.hpp"
 
 const static boost::uint16_t B200_VENDOR_ID  = 0x2500;
+const static boost::uint16_t B200_VENDOR_NI_ID = 0x3923;
 const static boost::uint16_t B200_PRODUCT_ID = 0x0020;
+const static boost::uint16_t B200_PRODUCT_NI_ID = 0x7813;
+const static boost::uint16_t B210_PRODUCT_NI_ID = 0x7814;
 const static boost::uint16_t FX3_VID = 0x04b4;
 const static boost::uint16_t FX3_DEFAULT_PID = 0x00f3;
 const static boost::uint16_t FX3_REENUM_PID = 0x00f0;
diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index b2f0d8d3e..9b323cb13 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -87,14 +87,16 @@ static device_addrs_t b200_find(const device_addr_t &hint)
     //since an address and resource is intended for a different, non-USB, device.
     if (hint.has_key("addr") || hint.has_key("resource")) return b200_addrs;
 
-    boost::uint16_t vid, pid;
+    size_t found = 0;
+    std::vector<usb_device_handle::vid_pid_pair_t> vid_pid_pair_list;//vid pid pair search list for devices.
 
     if(hint.has_key("vid") && hint.has_key("pid") && hint.has_key("type") && hint["type"] == "b200") {
-        vid = uhd::cast::hexstr_cast<boost::uint16_t>(hint.get("vid"));
-        pid = uhd::cast::hexstr_cast<boost::uint16_t>(hint.get("pid"));
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(uhd::cast::hexstr_cast<boost::uint16_t>(hint.get("vid")),
+                                                                    uhd::cast::hexstr_cast<boost::uint16_t>(hint.get("pid"))));
     } else {
-        vid = B200_VENDOR_ID;
-        pid = B200_PRODUCT_ID;
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID, B200_PRODUCT_ID));
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID, B200_PRODUCT_NI_ID));
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID, B210_PRODUCT_NI_ID));
     }
 
     // Important note:
@@ -104,8 +106,9 @@ static device_addrs_t b200_find(const device_addr_t &hint)
     // This requirement is a courtesy of libusb1.0 on windows.
 
     //find the usrps and load firmware
-    size_t found = 0;
-    BOOST_FOREACH(usb_device_handle::sptr handle, usb_device_handle::get_device_list(vid, pid)) {
+    std::vector<usb_device_handle::sptr> uhd_usb_device_vector = usb_device_handle::get_device_list(vid_pid_pair_list);
+
+    BOOST_FOREACH(usb_device_handle::sptr handle, uhd_usb_device_vector) {
         //extract the firmware path for the b200
         std::string b200_fw_image;
         try{
@@ -138,7 +141,7 @@ static device_addrs_t b200_find(const device_addr_t &hint)
     //search for the device until found or timeout
     while (boost::get_system_time() < timeout_time and b200_addrs.empty() and found != 0)
     {
-        BOOST_FOREACH(usb_device_handle::sptr handle, usb_device_handle::get_device_list(vid, pid))
+        BOOST_FOREACH(usb_device_handle::sptr handle, usb_device_handle::get_device_list(vid_pid_pair_list))
         {
             usb_control::sptr control;
             try{control = usb_control::make(handle, 0);}
@@ -155,12 +158,16 @@ static device_addrs_t b200_find(const device_addr_t &hint)
             {
                 switch (boost::lexical_cast<boost::uint16_t>(mb_eeprom["product"]))
                 {
+                //0x0001 and 0x7737 are Ettus B200 product Ids.
                 case 0x0001:
                 case 0x7737:
+                case B200_PRODUCT_NI_ID:
                     new_addr["product"] = "B200";
                     break;
-                case 0x7738:
+                //0x0002 and 0x7738 are Ettus B210 product Ids.
                 case 0x0002:
+                case 0x7738:
+                case B210_PRODUCT_NI_ID:
                     new_addr["product"] = "B210";
                     break;
                 default: UHD_MSG(error) << "B200 unknown product code: " << mb_eeprom["product"] << std::endl;
@@ -204,13 +211,50 @@ b200_impl::b200_impl(const device_addr_t &device_addr)
     //try to match the given device address with something on the USB bus
     boost::uint16_t vid = B200_VENDOR_ID;
     boost::uint16_t pid = B200_PRODUCT_ID;
+    bool specified_vid = false;
+    bool specified_pid = false;
+
     if (device_addr.has_key("vid"))
+    {
         vid = uhd::cast::hexstr_cast<boost::uint16_t>(device_addr.get("vid"));
+        specified_vid = true;
+    }
+
     if (device_addr.has_key("pid"))
+    {
         pid = uhd::cast::hexstr_cast<boost::uint16_t>(device_addr.get("pid"));
+        specified_pid = true;
+    }
+
+    std::vector<usb_device_handle::vid_pid_pair_t> vid_pid_pair_list;//search list for devices.
 
-    std::vector<usb_device_handle::sptr> device_list =
-        usb_device_handle::get_device_list(vid, pid);
+    // Search only for specified VID and PID if both specified
+    if (specified_vid && specified_pid)
+    {
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid,pid));
+    }
+    // Search for all supported PIDs limited to specified VID if only VID specified
+    else if (specified_vid)
+    {
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid,B200_PRODUCT_ID));
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid,B200_PRODUCT_NI_ID));
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(vid,B210_PRODUCT_NI_ID));
+    }
+    // Search for all supported VIDs limited to specified PID if only PID specified
+    else if (specified_pid)
+    {
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID,pid));
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID,pid));
+    }
+    // Search for all supported devices if neither VID nor PID specified
+    else
+    {
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_ID,B200_PRODUCT_ID));
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID,B200_PRODUCT_NI_ID));
+        vid_pid_pair_list.push_back(usb_device_handle::vid_pid_pair_t(B200_VENDOR_NI_ID,B210_PRODUCT_NI_ID));
+    }
+
+    std::vector<usb_device_handle::sptr> device_list = usb_device_handle::get_device_list(vid_pid_pair_list);
 
     //locate the matching handle in the device list
     usb_device_handle::sptr handle;
@@ -244,13 +288,17 @@ b200_impl::b200_impl(const device_addr_t &device_addr)
     {
         switch (boost::lexical_cast<boost::uint16_t>(mb_eeprom["product"]))
         {
+        //0x0001 and 0x7737 are Ettus B200 product Ids.
         case 0x0001:
         case 0x7737:
+        case B200_PRODUCT_NI_ID:
             product_name = "B200";
             default_file_name = B200_FPGA_FILE_NAME;
             break;
-        case 0x7738:
+        //0x0002 and 0x7738 are Ettus B210 product Ids.
         case 0x0002:
+        case 0x7738:
+        case B210_PRODUCT_NI_ID:
             product_name = "B210";
             default_file_name = B210_FPGA_FILE_NAME;
             break;
diff --git a/host/utils/b2xx_fx3_utils.cpp b/host/utils/b2xx_fx3_utils.cpp
index 8b64be63e..78449a8a4 100644
--- a/host/utils/b2xx_fx3_utils.cpp
+++ b/host/utils/b2xx_fx3_utils.cpp
@@ -54,17 +54,21 @@ const static vid_pid_t known_vid_pids[] = {
     {B200_VENDOR_ID, B200_PRODUCT_ID}
     };
 const static std::vector<vid_pid_t> known_vid_pid_vector(known_vid_pids, known_vid_pids + (sizeof(known_vid_pids) / sizeof(known_vid_pids[0])));
-const static boost::uint8_t eeprom_init_values[] = {
-    0x43,
-    0x59,
-    0x14,
-    0xB2,
-    (B200_PRODUCT_ID & 0xff),
-    (B200_PRODUCT_ID >> 8),
-    (B200_VENDOR_ID & 0xff),
-    (B200_VENDOR_ID >> 8)
-    };
-const static uhd::byte_vector_t eeprom_init_value_vector(eeprom_init_values, eeprom_init_values + (sizeof(eeprom_init_values) / sizeof(eeprom_init_values[0])));
+
+static const size_t EEPROM_INIT_VALUE_VECTOR_SIZE = 8;
+static uhd::byte_vector_t construct_eeprom_init_value_vector(boost::uint16_t vid, boost::uint16_t pid)
+{
+    uhd::byte_vector_t init_values(EEPROM_INIT_VALUE_VECTOR_SIZE);
+    init_values.push_back(0x43);
+    init_values.push_back(0x59);
+    init_values.push_back(0x14);
+    init_values.push_back(0xB2);
+    init_values.push_back(static_cast<boost::uint8_t>(pid & 0xff));
+    init_values.push_back(static_cast<boost::uint8_t>(pid >> 8));
+    init_values.push_back(static_cast<boost::uint8_t>(vid & 0xff));
+    init_values.push_back(static_cast<boost::uint8_t>(vid >> 8));
+    return init_values;
+}
 
 //!used with lexical cast to parse a hex string
 template <class T> struct to_hex{
@@ -153,15 +157,22 @@ uhd::transport::usb_device_handle::sptr open_device(const boost::uint16_t vid, c
 
     try {
         // try caller's VID/PID first
-        handles = uhd::transport::usb_device_handle::get_device_list(vp.vid,vp.pid);
-        if (user_supplied && handles.size() == 0)
-            std::cerr << (boost::format("Failed to open device with VID 0x%04x and PID 0x%04x - trying other known VID/PIDs") % vid % pid).str() << std::endl;
-
-        // try known VID/PIDs next
-        for (size_t i = 0; handles.size() == 0 && i < known_vid_pid_vector.size(); i++)
+        std::vector<uhd::transport::usb_device_handle::vid_pid_pair_t> vid_pid_pair_list(1,uhd::transport::usb_device_handle::vid_pid_pair_t(vid,pid));
+        handles = uhd::transport::usb_device_handle::get_device_list(vid_pid_pair_list);
+        if (handles.size() == 0)
         {
-            vp = known_vid_pid_vector[i];
-            handles = uhd::transport::usb_device_handle::get_device_list(vp.vid,vp.pid);
+            if (user_supplied)
+            {
+                std::cerr << (boost::format("Failed to open device with VID 0x%04x and PID 0x%04x - trying other known VID/PIDs") % vid % pid).str() << std::endl;
+            }
+
+            // try known VID/PIDs next
+            for (size_t i = 0; handles.size() == 0 && i < known_vid_pid_vector.size(); i++)
+            {
+                vp = known_vid_pid_vector[i];
+                handles = uhd::transport::usb_device_handle::get_device_list(vp.vid, vp.pid);
+            }
+           
         }
 
         if (handles.size() > 0)
@@ -281,7 +292,7 @@ int erase_eeprom(b200_iface::sptr& b200)
 
 boost::int32_t main(boost::int32_t argc, char *argv[]) {
     boost::uint16_t vid, pid;
-    std::string pid_str, vid_str, fw_file, fpga_file;
+    std::string pid_str, vid_str, fw_file, fpga_file, writevid_str, writepid_str;
     bool user_supplied_vid_pid = false;
 
     po::options_description visible("Allowed options");
@@ -295,7 +306,6 @@ boost::int32_t main(boost::int32_t argc, char *argv[]) {
         ("reset-device,D", "Reset the B2xx Device.")
         ("reset-fpga,F", "Reset the FPGA (does not require re-programming.")
         ("reset-usb,U", "Reset the USB subsystem on your host computer.")
-        ("init-device,I", "Initialize a B2xx device.")
         ("load-fw,W", po::value<std::string>(&fw_file),
             "Load a firmware (hex) file into the FX3.")
         ("load-fpga,L", po::value<std::string>(&fpga_file),
@@ -305,9 +315,14 @@ boost::int32_t main(boost::int32_t argc, char *argv[]) {
     // Hidden options provided for testing - use at your own risk!
     po::options_description hidden("Hidden options");
     hidden.add_options()
-    ("uninit-device,U", "Uninitialize a B2xx device.")
+    ("init-device,I", "Initialize a B2xx device.")
+    ("uninit-device", "Uninitialize a B2xx device.")
     ("read-eeprom,R", "Read first 8 bytes of EEPROM")
-    ("erase-eeprom,E", "Erase first 8 bytes of EEPROM");
+    ("erase-eeprom,E", "Erase first 8 bytes of EEPROM")
+    ("write-vid", po::value<std::string>(&writevid_str),
+        "Write VID field of EEPROM")
+    ("write-pid", po::value<std::string>(&writepid_str),
+        "Write PID field of EEPROM");
 
     po::options_description desc;
     desc.add(visible);
@@ -486,9 +501,24 @@ boost::int32_t main(boost::int32_t argc, char *argv[]) {
      * Cypress VID/PID for the initial FW load, but we can initialize from any state. */
     if (vm.count("init-device"))
     {
+        uint16_t writevid = B200_VENDOR_ID;
+        uint16_t writepid = B200_PRODUCT_ID;
+
         /* Now, initialize the device. */
-        if (write_and_verify_eeprom(b200, eeprom_init_value_vector))
-            return -1;
+           // Added for testing purposes - not exposed
+        if (vm.count("write-vid") && vm.count("write-pid"))
+        {
+            try {
+                  writevid = atoh(writevid_str);
+                  writepid = atoh(writepid_str);
+            } catch (std::exception &e) {
+                  std::cerr << "Exception while parsing write VID and PID: " << e.what() << std:: endl;
+                  return ~0;
+            }
+        }
+
+        std::cout << "Writing VID and PID to EEPROM..." << std::endl << std::endl;
+        if (write_and_verify_eeprom(b200, construct_eeprom_init_value_vector(writevid, writepid))) return -1;
 
         std::cout << "EEPROM initialized, resetting device..."
             << std::endl << std::endl;
-- 
cgit v1.2.3


From 93bd61a0fec4ea7e81ba78f62fb998116266ac96 Mon Sep 17 00:00:00 2001
From: Julian Arnold <julian.arnold@ettus.com>
Date: Tue, 20 Jan 2015 08:55:37 -0800
Subject: b200: Expose temperature sensor through property tree (sensors/temp)

---
 host/lib/usrp/b200/b200_impl.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'host/lib/usrp/b200')

diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index 8ea50296f..22e68c4ed 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -710,6 +710,8 @@ void b200_impl::setup_radio(const size_t dspno)
             .set(B200_DEFAULT_FREQ);
         _tree->create<meta_range_t>(rf_fe_path / "freq" / "range")
             .publish(boost::bind(&ad9361_ctrl::get_rf_freq_range));
+        _tree->create<sensor_value_t>(rf_fe_path / "sensors" / "temp")
+                .publish(boost::bind(&ad9361_ctrl::get_temperature, _codec_ctrl));
 
         //setup RX related stuff
         if (key[0] == 'R')
-- 
cgit v1.2.3


From 1d1976c48e8ca698d9c35636823c8ea39dc69129 Mon Sep 17 00:00:00 2001
From: mcrymble <matthew.crymble@ni.com>
Date: Fri, 6 Feb 2015 16:10:24 -0600
Subject: b200: Bugfix#692: b200_find now returns an empty device vector when
 hint contains addr0/resource0/etc style keys.

---
 host/lib/usrp/b200/b200_impl.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'host/lib/usrp/b200')

diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index 355d12d12..13169a5ed 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -86,7 +86,9 @@ static device_addrs_t b200_find(const device_addr_t &hint)
 
     //Return an empty list of addresses when an address or resource is specified,
     //since an address and resource is intended for a different, non-USB, device.
-    if (hint.has_key("addr") || hint.has_key("resource")) return b200_addrs;
+    BOOST_FOREACH(device_addr_t hint_i, separate_device_addr(hint)) {
+        if (hint_i.has_key("addr") || hint_i.has_key("resource")) return b200_addrs;
+    }
 
     boost::uint16_t vid, pid;
 
-- 
cgit v1.2.3


From ef00232f60777e0beab71cc749948e8389e3de84 Mon Sep 17 00:00:00 2001
From: Marcus Müller <marcus.mueller@ettus.com>
Date: Mon, 16 Feb 2015 19:16:22 +0100
Subject: b200: removed CMakeLists copy&paste B100 remains

---
 host/lib/usrp/b200/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'host/lib/usrp/b200')

diff --git a/host/lib/usrp/b200/CMakeLists.txt b/host/lib/usrp/b200/CMakeLists.txt
index a08c4bd03..ce89b5d80 100644
--- a/host/lib/usrp/b200/CMakeLists.txt
+++ b/host/lib/usrp/b200/CMakeLists.txt
@@ -20,7 +20,7 @@
 ########################################################################
 
 ########################################################################
-# Conditionally configure the B100 support
+# Conditionally configure the B200 support
 ########################################################################
 LIBUHD_REGISTER_COMPONENT("B200" ENABLE_B200 ON "ENABLE_LIBUHD;ENABLE_USB" OFF)
 
-- 
cgit v1.2.3


From 2b06c3815551c99d7691a7aa3dbcf6eaedc9e998 Mon Sep 17 00:00:00 2001
From: Julian Arnold <julian.arnold@ettus.com>
Date: Fri, 20 Feb 2015 10:51:45 -0800
Subject: b2xx: dc offset and iq imbalance correction control

---
 host/lib/usrp/b200/b200_impl.cpp                   |  14 +-
 host/lib/usrp/common/ad9361_ctrl.cpp               |  28 ++++
 host/lib/usrp/common/ad9361_ctrl.hpp               |  15 +-
 .../usrp/common/ad9361_driver/ad9361_device.cpp    | 125 +++++++++++++---
 host/lib/usrp/common/ad9361_driver/ad9361_device.h |   9 ++
 .../usrp/common/ad9361_driver/ad9361_gain_tables.h | 162 ++++++++++-----------
 6 files changed, 245 insertions(+), 108 deletions(-)

(limited to 'host/lib/usrp/b200')

diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index c1729ead3..ada25ad59 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -591,7 +591,7 @@ b200_impl::b200_impl(const device_addr_t &device_addr)
 
 b200_impl::~b200_impl(void)
 {
-	UHD_SAFE_CALL
+    UHD_SAFE_CALL
     (
         _async_task.reset();
     )
@@ -702,7 +702,7 @@ void b200_impl::setup_radio(const size_t dspno)
         _tree->create<bool>(rf_fe_path / "use_lo_offset").set(false);
         _tree->create<double>(rf_fe_path / "bandwidth" / "value")
             .coerce(boost::bind(&ad9361_ctrl::set_bw_filter, _codec_ctrl, key, _1))
-            .set(40e6);
+            .set(56e6);
         _tree->create<meta_range_t>(rf_fe_path / "bandwidth" / "range")
             .publish(boost::bind(&ad9361_ctrl::get_bw_filter_range, key));
         _tree->create<double>(rf_fe_path / "freq" / "value")
@@ -715,6 +715,16 @@ void b200_impl::setup_radio(const size_t dspno)
                 .publish(boost::bind(&ad9361_ctrl::get_temperature, _codec_ctrl));
 
         //setup RX related stuff
+        if(direction)
+        {
+            _tree->create<bool>(rf_fe_path / "dc_offset" / "enable" )
+                .subscribe(boost::bind(&ad9361_ctrl::set_dc_offset_auto, _codec_ctrl, key, _1)).set(true);
+
+            _tree->create<bool>(rf_fe_path / "iq_balance" / "enable" )
+                .subscribe(boost::bind(&ad9361_ctrl::set_iq_balance_auto, _codec_ctrl, key, _1)).set(true);
+        }
+
+        //setup antenna stuff
         if (key[0] == 'R')
         {
             static const std::vector<std::string> ants = boost::assign::list_of("TX/RX")("RX2");
diff --git a/host/lib/usrp/common/ad9361_ctrl.cpp b/host/lib/usrp/common/ad9361_ctrl.cpp
index 3db6739e7..4a3c17cf1 100644
--- a/host/lib/usrp/common/ad9361_ctrl.cpp
+++ b/host/lib/usrp/common/ad9361_ctrl.cpp
@@ -178,6 +178,34 @@ public:
         return sensor_value_t("temp", _device.get_average_temperature(), "C");
     }
 
+    void set_dc_offset_auto(const std::string &which, const bool on)
+    {
+        boost::lock_guard<boost::mutex> lock(_mutex);
+
+        ad9361_device_t::direction_t direction = _get_direction_from_antenna(which);
+        _device.set_dc_offset_auto(direction,on);
+    }
+
+    void set_dc_offset(const std::string &which, const std::complex<double> value)
+    {
+        //This feature should not be used according to Analog Devices
+        throw uhd::runtime_error("ad9361_ctrl::set_dc_offset this feature is not supported on this device.");
+    }
+
+    void set_iq_balance_auto(const std::string &which, const bool on)
+    {
+        boost::lock_guard<boost::mutex> lock(_mutex);
+
+        ad9361_device_t::direction_t direction = _get_direction_from_antenna(which);
+        _device.set_iq_balance_auto(direction,on);
+    }
+
+    void set_iq_balance(const std::string &which, const std::complex<double> value)
+    {
+        //This feature should not be used according to Analog Devices
+        throw uhd::runtime_error("ad9361_ctrl::set_iq_balance this feature is not supported on this device.");
+    }
+
 private:
     static ad9361_device_t::direction_t _get_direction_from_antenna(const std::string& antenna)
     {
diff --git a/host/lib/usrp/common/ad9361_ctrl.hpp b/host/lib/usrp/common/ad9361_ctrl.hpp
index f831f870d..94eee608e 100644
--- a/host/lib/usrp/common/ad9361_ctrl.hpp
+++ b/host/lib/usrp/common/ad9361_ctrl.hpp
@@ -25,6 +25,7 @@
 #include <boost/shared_ptr.hpp>
 #include <ad9361_device.h>
 #include <string>
+#include <complex>
 
 namespace uhd { namespace usrp {
 
@@ -95,7 +96,19 @@ public:
     //! tune the given frontend, return the exact value
     virtual double tune(const std::string &which, const double value) = 0;
 
-    //! turn on/off data port loopback
+    //! set the DC offset for I and Q manually
+    virtual void set_dc_offset(const std::string &which, const std::complex<double> value) = 0;
+
+    //! enable or disable the BB/RF DC tracking feature
+    virtual void set_dc_offset_auto(const std::string &which, const bool on) = 0;
+
+    //! set the IQ correction value manually
+    virtual void set_iq_balance(const std::string &which, const std::complex<double> value) = 0;
+
+    //! enable or disable the quadrature calibration
+    virtual void set_iq_balance_auto(const std::string &which, const bool on) = 0;
+
+    //! turn on/off Catalina's data port loopback
     virtual void data_port_loopback(const bool on) = 0;
 
     //! read internal RSSI sensor
diff --git a/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp b/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp
index f1a82d71c..e5938184c 100644
--- a/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp
+++ b/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp
@@ -11,6 +11,7 @@
 #include <cmath>
 #include <uhd/exception.hpp>
 #include <uhd/utils/log.hpp>
+#include <uhd/utils/msg.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/thread/thread.hpp>
@@ -650,11 +651,12 @@ void ad9361_device_t::_setup_adc()
 }
 
 /* Calibrate the baseband DC offset.
- *
- * Note that this function is called from within the TX quadrature
- * calibration function! */
+ * Disables tracking
+ */
 void ad9361_device_t::_calibrate_baseband_dc_offset()
 {
+    _io_iface->poke8(0x18b, 0x83); //Reset RF DC tracking flag
+
     _io_iface->poke8(0x193, 0x3f); // Calibration settings
     _io_iface->poke8(0x190, 0x0f); // Set tracking coefficient
     //write_ad9361_reg(device, 0x190, /*0x0f*//*0xDF*/0x80*1 | 0x40*1 | (16+8/*+4*/)); // Set tracking coefficient: don't *4 counter, do decim /4, increased gain shift
@@ -674,9 +676,8 @@ void ad9361_device_t::_calibrate_baseband_dc_offset()
 }
 
 /* Calibrate the RF DC offset.
- *
- * Note that this function is called from within the TX quadrature
- * calibration function. */
+ * Disables tracking
+ */
 void ad9361_device_t::_calibrate_rf_dc_offset()
 {
     /* Some settings are frequency-dependent. */
@@ -691,7 +692,7 @@ void ad9361_device_t::_calibrate_rf_dc_offset()
     }
 
     _io_iface->poke8(0x185, 0x20); // RF DC Offset wait count
-    _io_iface->poke8(0x18b, 0x83);
+    _io_iface->poke8(0x18b, 0x83); // Disable tracking
     _io_iface->poke8(0x189, 0x30);
 
     /* Run the calibration! */
@@ -707,6 +708,16 @@ void ad9361_device_t::_calibrate_rf_dc_offset()
     }
 }
 
+void ad9361_device_t::_configure_bb_rf_dc_tracking(const bool on)
+{
+    if(on)
+    {
+        _io_iface->poke8(0x18b, 0xad); // Enable BB and RF DC tracking
+    } else {
+        _io_iface->poke8(0x18b, 0x83); // Disable BB and RF DC tracking
+    }
+}
+
 /* Start the RX quadrature calibration.
  *
  * Note that we are using AD9361's 'tracking' feature for RX quadrature
@@ -719,16 +730,20 @@ void ad9361_device_t::_calibrate_rx_quadrature()
     _io_iface->poke8(0x16e, 0x25); // RX Gain index to use for cal
     _io_iface->poke8(0x16a, 0x75); // Set Kexp phase
     _io_iface->poke8(0x16b, 0x15); // Set Kexp amplitude
-    _io_iface->poke8(0x169, 0xcf); // Continuous tracking mode
-    _io_iface->poke8(0x18b, 0xad);
+
+    if(_use_iq_balance_correction)
+    {
+        _io_iface->poke8(0x169, 0xcf); // Continuous tracking mode. Gets disabled in _tx_quadrature_cal_routine!
+    }
 }
 
-/* TX quadtrature calibration routine.
+/* TX quadrature calibration routine.
  *
  * The TX quadrature needs to be done twice, once for each TX chain, with
  * only one register change in between. Thus, this function enacts the
  * calibrations, and it is called from calibrate_tx_quadrature. */
 void ad9361_device_t::_tx_quadrature_cal_routine() {
+
     /* This is a weird process, but here is how it works:
      * 1) Read the calibrated NCO frequency bits out of 0A3.
      * 2) Write the two bits to the RX NCO freq part of 0A0.
@@ -773,12 +788,6 @@ void ad9361_device_t::_tx_quadrature_cal_routine() {
     _io_iface->poke8(0x0a4, 0xf0); // Cal setting conut
     _io_iface->poke8(0x0ae, 0x00); // Cal LPF gain index (split mode)
 
-    /* First, calibrate the baseband DC offset. */
-    _calibrate_baseband_dc_offset();
-
-    /* Second, calibrate the RF DC offset. */
-    _calibrate_rf_dc_offset();
-
     /* Now, calibrate the TX quadrature! */
     size_t count = 0;
     _io_iface->poke8(0x016, 0x10);
@@ -793,9 +802,7 @@ void ad9361_device_t::_tx_quadrature_cal_routine() {
 }
 
 /* Run the TX quadrature calibration.
- *
- * Note that from within this function we are also triggering the baseband
- * and RF DC calibrations. */
+ */
 void ad9361_device_t::_calibrate_tx_quadrature()
 {
     /* Make sure we are, in fact, in the ALERT state. If not, something is
@@ -879,7 +886,7 @@ void ad9361_device_t::_program_mixer_gm_subtable()
 void ad9361_device_t::_program_gain_table() {
     /* Figure out which gain table we should be using for our current
      * frequency band. */
-    boost::uint8_t (*gain_table)[5] = NULL;
+    boost::uint8_t (*gain_table)[3] = NULL;
     boost::uint8_t new_gain_table;
     if (_rx_freq < 1300e6) {
         gain_table = gain_table_sub_1300mhz;
@@ -910,9 +917,9 @@ void ad9361_device_t::_program_gain_table() {
     boost::uint8_t index = 0;
     for (; index < 77; index++) {
         _io_iface->poke8(0x130, index);
-        _io_iface->poke8(0x131, gain_table[index][1]);
-        _io_iface->poke8(0x132, gain_table[index][2]);
-        _io_iface->poke8(0x133, gain_table[index][3]);
+        _io_iface->poke8(0x131, gain_table[index][0]);
+        _io_iface->poke8(0x132, gain_table[index][1]);
+        _io_iface->poke8(0x133, gain_table[index][2]);
         _io_iface->poke8(0x137, 0x1E);
         _io_iface->poke8(0x134, 0x00);
         _io_iface->poke8(0x134, 0x00);
@@ -1256,6 +1263,7 @@ double ad9361_device_t::_setup_rates(const double rate)
     int divfactor = 0;
     _tfir_factor = 0;
     _rfir_factor = 0;
+
     if (rate < 0.33e6) {
         // RX1 + RX2 enabled, 3, 2, 2, 4
         _regs.rxfilt = B8(11101111);
@@ -1411,6 +1419,8 @@ void ad9361_device_t::initialize()
     _rx2_gain = 0;
     _tx1_gain = 0;
     _tx2_gain = 0;
+    _use_dc_offset_correction = true;
+    _use_iq_balance_correction = true;
 
     /* Reset the device. */
     _io_iface->poke8(0x000, 0x01);
@@ -1563,8 +1573,11 @@ void ad9361_device_t::initialize()
 
     _setup_adc();
 
+    _calibrate_baseband_dc_offset();
+    _calibrate_rf_dc_offset();
     _calibrate_tx_quadrature();
     _calibrate_rx_quadrature();
+    _configure_bb_rf_dc_tracking(_use_dc_offset_correction);
 
     // cals done, set PPORT config
     switch (_client_params->get_digital_interface_mode()) {
@@ -1687,8 +1700,11 @@ double ad9361_device_t::set_clock_rate(const double req_rate)
 
     _setup_adc();
 
+    _calibrate_baseband_dc_offset();
+    _calibrate_rf_dc_offset();
     _calibrate_tx_quadrature();
     _calibrate_rx_quadrature();
+    _configure_bb_rf_dc_tracking(_use_dc_offset_correction);
 
     // cals done, set PPORT config
     switch (_client_params->get_digital_interface_mode()) {
@@ -1841,9 +1857,11 @@ double ad9361_device_t::tune(direction_t direction, const double value)
     _reprogram_gains();
 
     /* Run the calibration algorithms. */
+    _calibrate_baseband_dc_offset();
+    _calibrate_rf_dc_offset();
     _calibrate_tx_quadrature();
     _calibrate_rx_quadrature();
-
+    _configure_bb_rf_dc_tracking(_use_dc_offset_correction); //if this is not done here, bb dc offset is not good
     /* If we were in the FDD state, return it now. */
     if (not_in_alert) {
         _io_iface->poke8(0x014, 0x21);
@@ -1990,4 +2008,63 @@ double ad9361_device_t::get_average_temperature(const double cal_offset, const s
     return d_temp;
 }
 
+void ad9361_device_t::set_dc_offset_auto(direction_t direction, const bool on)
+{
+    if(direction == RX)
+    {
+         _use_dc_offset_correction = on;
+         _configure_bb_rf_dc_tracking(_use_dc_offset_correction);
+        if(on)
+        {
+            _io_iface->poke8(0x182, (_io_iface->peek8(0x182) & (~((1 << 7) | (1 << 6) | (1 << 3) | (1 << 2))))); //Clear force bits
+            //Do a single shot DC offset cal before enabling tracking (Not possible if not in ALERT state. Is it necessary?)
+        } else {
+            //clear current config values
+            _io_iface->poke8(0x182, (_io_iface->peek8(0x182) | ((1 << 7) | (1 << 6) | (1 << 3) | (1 << 2)))); //Set input A and input B&C force enable bits
+            _io_iface->poke8(0x174, 0x00);
+            _io_iface->poke8(0x175, 0x00);
+            _io_iface->poke8(0x176, 0x00);
+            _io_iface->poke8(0x177, 0x00);
+            _io_iface->poke8(0x178, 0x00);
+            _io_iface->poke8(0x17D, 0x00);
+            _io_iface->poke8(0x17E, 0x00);
+            _io_iface->poke8(0x17F, 0x00);
+            _io_iface->poke8(0x180, 0x00);
+            _io_iface->poke8(0x181, 0x00);
+        }
+    } else {
+        // DC offset is removed during TX quad cal
+        throw uhd::runtime_error("[ad9361_device_t] [set_iq_balance_auto] INVALID_CODE_PATH");
+    }
+}
+
+void ad9361_device_t::set_iq_balance_auto(direction_t direction, const bool on)
+{
+    if(direction == RX)
+    {
+        _use_iq_balance_correction = on;
+        if(on)
+        {
+            //disable force registers and enable tracking
+            _io_iface->poke8(0x182, (_io_iface->peek8(0x182) & (~ ( (1<<1) | (1<<0) | (1<<5) | (1<<4) ))));
+            _calibrate_rx_quadrature();
+        } else {
+            //disable IQ tracking
+            _io_iface->poke8(0x169, 0xc0);
+            //clear current config values
+            _io_iface->poke8(0x182, (_io_iface->peek8(0x182) | ((1 << 1) | (1 << 0) | (1 << 5) | (1 << 4)))); //Set Rx2 input B&C force enable bit
+            _io_iface->poke8(0x17B, 0x00);
+            _io_iface->poke8(0x17C, 0x00);
+            _io_iface->poke8(0x179, 0x00);
+            _io_iface->poke8(0x17A, 0x00);
+            _io_iface->poke8(0x170, 0x00);
+            _io_iface->poke8(0x171, 0x00);
+            _io_iface->poke8(0x172, 0x00);
+            _io_iface->poke8(0x173, 0x00);
+        }
+    } else {
+        throw uhd::runtime_error("[ad9361_device_t] [set_iq_balance_auto] INVALID_CODE_PATH");
+    }
+}
+
 }}
diff --git a/host/lib/usrp/common/ad9361_driver/ad9361_device.h b/host/lib/usrp/common/ad9361_driver/ad9361_device.h
index 8f64922f8..93dc413d5 100644
--- a/host/lib/usrp/common/ad9361_driver/ad9361_device.h
+++ b/host/lib/usrp/common/ad9361_driver/ad9361_device.h
@@ -72,6 +72,12 @@ public:
      */
     double get_average_temperature(const double cal_offset = -30.0, const size_t num_samples = 3);
 
+    /* Turn on/off AD9361's RX DC offset correction */
+    void set_dc_offset_auto(direction_t direction, const bool on);
+
+    /* Turn on/off AD9361's RX IQ imbalance correction */
+    void set_iq_balance_auto(direction_t direction, const bool on);
+
     //Constants
     static const double AD9361_MAX_GAIN;
     static const double AD9361_MAX_CLOCK_RATE;
@@ -102,6 +108,7 @@ private:    //Methods
     double _tune_helper(direction_t direction, const double value);
     double _setup_rates(const double rate);
     double _get_temperature(const double cal_offset, const double timeout = 0.1);
+    void _configure_bb_rf_dc_tracking(const bool on);
 
 private:    //Members
     typedef struct {
@@ -130,6 +137,8 @@ private:    //Members
     chip_regs_t         _regs;
     //Synchronization
     boost::recursive_mutex  _mutex;
+    bool _use_dc_offset_correction;
+    bool _use_iq_balance_correction;
 };
 
 }}  //namespace
diff --git a/host/lib/usrp/common/ad9361_driver/ad9361_gain_tables.h b/host/lib/usrp/common/ad9361_driver/ad9361_gain_tables.h
index 786029d6e..553655fa5 100644
--- a/host/lib/usrp/common/ad9361_driver/ad9361_gain_tables.h
+++ b/host/lib/usrp/common/ad9361_driver/ad9361_gain_tables.h
@@ -7,91 +7,91 @@
 
 #include <boost/cstdint.hpp>
 
-boost::uint8_t gain_table_sub_1300mhz[77][5] = { {0,0x00,0x00,0x20,1},
-    {1,0x00,0x00,0x00,0}, {2,0x00,0x00,0x00,0}, {3,0x00,0x01,0x00,0},
-    {4,0x00,0x02,0x00,0}, {5,0x00,0x03,0x00,0}, {6,0x00,0x04,0x00,0},
-    {7,0x00,0x05,0x00,0}, {8,0x01,0x03,0x20,1}, {9,0x01,0x04,0x00,0},
-    {10,0x01,0x05,0x00,0}, {11,0x01,0x06,0x00,0}, {12,0x01,0x07,0x00,0},
-    {13,0x01,0x08,0x00,0}, {14,0x01,0x09,0x00,0}, {15,0x01,0x0A,0x00,0},
-    {16,0x01,0x0B,0x00,0}, {17,0x01,0x0C,0x00,0}, {18,0x01,0x0D,0x00,0},
-    {19,0x01,0x0E,0x00,0}, {20,0x02,0x09,0x20,1}, {21,0x02,0x0A,0x00,0},
-    {22,0x02,0x0B,0x00,0}, {23,0x02,0x0C,0x00,0}, {24,0x02,0x0D,0x00,0},
-    {25,0x02,0x0E,0x00,0}, {26,0x02,0x0F,0x00,0}, {27,0x02,0x10,0x00,0},
-    {28,0x02,0x2B,0x20,1}, {29,0x02,0x2C,0x00,0}, {30,0x04,0x27,0x20,1},
-    {31,0x04,0x28,0x00,0}, {32,0x04,0x29,0x00,0}, {33,0x04,0x2A,0x00,0},
-    {34,0x04,0x2B,0x00,1}, {35,0x24,0x21,0x20,0}, {36,0x24,0x22,0x00,1},
-    {37,0x44,0x20,0x20,0}, {38,0x44,0x21,0x00,0}, {39,0x44,0x22,0x00,0},
-    {40,0x44,0x23,0x00,0}, {41,0x44,0x24,0x00,0}, {42,0x44,0x25,0x00,0},
-    {43,0x44,0x26,0x00,0}, {44,0x44,0x27,0x00,0}, {45,0x44,0x28,0x00,0},
-    {46,0x44,0x29,0x00,0}, {47,0x44,0x2A,0x00,0}, {48,0x44,0x2B,0x00,0},
-    {49,0x44,0x2C,0x00,0}, {50,0x44,0x2D,0x00,0}, {51,0x44,0x2E,0x00,0},
-    {52,0x44,0x2F,0x00,0}, {53,0x44,0x30,0x00,0}, {54,0x44,0x31,0x00,0},
-    {55,0x64,0x2E,0x20,1}, {56,0x64,0x2F,0x00,0}, {57,0x64,0x30,0x00,0},
-    {58,0x64,0x31,0x00,0}, {59,0x64,0x32,0x00,0}, {60,0x64,0x33,0x00,0},
-    {61,0x64,0x34,0x00,0}, {62,0x64,0x35,0x00,0}, {63,0x64,0x36,0x00,0},
-    {64,0x64,0x37,0x00,0}, {65,0x64,0x38,0x00,0}, {66,0x65,0x38,0x20,1},
-    {67,0x66,0x38,0x20,1}, {68,0x67,0x38,0x20,1}, {69,0x68,0x38,0x20,1},
-    {70,0x69,0x38,0x20,1}, {71,0x6A,0x38,0x20,1}, {72,0x6B,0x38,0x20,1},
-    {73,0x6C,0x38,0x20,1}, {74,0x6D,0x38,0x20,1}, {75,0x6E,0x38,0x20,1},
-    {76,0x6F,0x38,0x20,1}};
+boost::uint8_t gain_table_sub_1300mhz[77][3] = {
+{ 0x00, 0x00, 0x20 }, { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 },
+{ 0x00, 0x01, 0x00 }, { 0x00, 0x02, 0x00 }, { 0x00, 0x03, 0x00 },
+{ 0x00, 0x04, 0x00 }, { 0x00, 0x05, 0x00 }, { 0x01, 0x03, 0x20 },
+{ 0x01, 0x04, 0x00 }, { 0x01, 0x05, 0x00 }, { 0x01, 0x06, 0x00 },
+{ 0x01, 0x07, 0x00 }, { 0x01, 0x08, 0x00 }, { 0x01, 0x09, 0x00 },
+{ 0x01, 0x0A, 0x00 }, { 0x01, 0x0B, 0x00 }, { 0x01, 0x0C, 0x00 },
+{ 0x01, 0x0D, 0x00 }, { 0x01, 0x0E, 0x00 }, { 0x02, 0x09, 0x20 },
+{ 0x02, 0x0A, 0x00 }, { 0x02, 0x0B, 0x00 }, { 0x02, 0x0C, 0x00 },
+{ 0x02, 0x0D, 0x00 }, { 0x02, 0x0E, 0x00 }, { 0x02, 0x0F, 0x00 },
+{ 0x02, 0x10, 0x00 }, { 0x02, 0x2B, 0x20 }, { 0x02, 0x2C, 0x00 },
+{ 0x04, 0x28, 0x20 }, { 0x04, 0x29, 0x00 }, { 0x04, 0x2A, 0x00 },
+{ 0x04, 0x2B, 0x00 }, { 0x24, 0x20, 0x20 }, { 0x24, 0x21, 0x00 },
+{ 0x44, 0x20, 0x20 }, { 0x44, 0x21, 0x00 }, { 0x44, 0x22, 0x00 },
+{ 0x44, 0x23, 0x00 }, { 0x44, 0x24, 0x00 }, { 0x44, 0x25, 0x00 },
+{ 0x44, 0x26, 0x00 }, { 0x44, 0x27, 0x00 }, { 0x44, 0x28, 0x00 },
+{ 0x44, 0x29, 0x00 }, { 0x44, 0x2A, 0x00 }, { 0x44, 0x2B, 0x00 },
+{ 0x44, 0x2C, 0x00 }, { 0x44, 0x2D, 0x00 }, { 0x44, 0x2E, 0x00 },
+{ 0x44, 0x2F, 0x00 }, { 0x44, 0x30, 0x00 }, { 0x44, 0x31, 0x00 },
+{ 0x44, 0x32, 0x00 }, { 0x64, 0x2E, 0x20 }, { 0x64, 0x2F, 0x00 },
+{ 0x64, 0x30, 0x00 }, { 0x64, 0x31, 0x00 }, { 0x64, 0x32, 0x00 },
+{ 0x64, 0x33, 0x00 }, { 0x64, 0x34, 0x00 }, { 0x64, 0x35, 0x00 },
+{ 0x64, 0x36, 0x00 }, { 0x64, 0x37, 0x00 }, { 0x64, 0x38, 0x00 },
+{ 0x65, 0x38, 0x20 }, { 0x66, 0x38, 0x20 }, { 0x67, 0x38, 0x20 },
+{ 0x68, 0x38, 0x20 }, { 0x69, 0x38, 0x20 }, { 0x6A, 0x38, 0x20 },
+{ 0x6B, 0x38, 0x20 }, { 0x6C, 0x38, 0x20 }, { 0x6D, 0x38, 0x20 },
+{ 0x6E, 0x38, 0x20 }, { 0x6F, 0x38, 0x20 } };
 
 
-boost::uint8_t gain_table_1300mhz_to_4000mhz[77][5] = {   {0,0x00,0x00,0x20,1},
-    {1,0x00,0x00,0x00,0}, {2,0x00,0x00,0x00,0}, {3,0x00,0x01,0x00,0},
-    {4,0x00,0x02,0x00,0}, {5,0x00,0x03,0x00,0}, {6,0x00,0x04,0x00,0},
-    {7,0x00,0x05,0x00,0}, {8,0x01,0x03,0x20,1}, {9,0x01,0x04,0x00,0},
-    {10,0x01,0x05,0x00,0}, {11,0x01,0x06,0x00,0}, {12,0x01,0x07,0x00,0},
-    {13,0x01,0x08,0x00,0}, {14,0x01,0x09,0x00,0}, {15,0x01,0x0A,0x00,0},
-    {16,0x01,0x0B,0x00,0}, {17,0x01,0x0C,0x00,0}, {18,0x01,0x0D,0x00,0},
-    {19,0x01,0x0E,0x00,0}, {20,0x02,0x09,0x20,1}, {21,0x02,0x0A,0x00,0},
-    {22,0x02,0x0B,0x00,0}, {23,0x02,0x0C,0x00,0}, {24,0x02,0x0D,0x00,0},
-    {25,0x02,0x0E,0x00,0}, {26,0x02,0x0F,0x00,0}, {27,0x02,0x10,0x00,0},
-    {28,0x02,0x2B,0x20,1}, {29,0x02,0x2C,0x00,0}, {30,0x04,0x28,0x20,1},
-    {31,0x04,0x29,0x00,0}, {32,0x04,0x2A,0x00,0}, {33,0x04,0x2B,0x00,0},
-    {34,0x24,0x20,0x20,0}, {35,0x24,0x21,0x00,1}, {36,0x44,0x20,0x20,0},
-    {37,0x44,0x21,0x00,1}, {38,0x44,0x22,0x00,0}, {39,0x44,0x23,0x00,0},
-    {40,0x44,0x24,0x00,0}, {41,0x44,0x25,0x00,0}, {42,0x44,0x26,0x00,0},
-    {43,0x44,0x27,0x00,0}, {44,0x44,0x28,0x00,0}, {45,0x44,0x29,0x00,0},
-    {46,0x44,0x2A,0x00,0}, {47,0x44,0x2B,0x00,0}, {48,0x44,0x2C,0x00,0},
-    {49,0x44,0x2D,0x00,0}, {50,0x44,0x2E,0x00,0}, {51,0x44,0x2F,0x00,0},
-    {52,0x44,0x30,0x00,0}, {53,0x44,0x31,0x00,0}, {54,0x44,0x32,0x00,0},
-    {55,0x64,0x2E,0x20,1}, {56,0x64,0x2F,0x00,0}, {57,0x64,0x30,0x00,0},
-    {58,0x64,0x31,0x00,0}, {59,0x64,0x32,0x00,0}, {60,0x64,0x33,0x00,0},
-    {61,0x64,0x34,0x00,0}, {62,0x64,0x35,0x00,0}, {63,0x64,0x36,0x00,0},
-    {64,0x64,0x37,0x00,0}, {65,0x64,0x38,0x00,0}, {66,0x65,0x38,0x20,1},
-    {67,0x66,0x38,0x20,1}, {68,0x67,0x38,0x20,1}, {69,0x68,0x38,0x20,1},
-    {70,0x69,0x38,0x20,1}, {71,0x6A,0x38,0x20,1}, {72,0x6B,0x38,0x20,1},
-    {73,0x6C,0x38,0x20,1}, {74,0x6D,0x38,0x20,1}, {75,0x6E,0x38,0x20,1},
-    {76,0x6F,0x38,0x20,1}};
+boost::uint8_t gain_table_1300mhz_to_4000mhz[77][3] = {
+{ 0x00, 0x00, 0x20 }, { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 },
+{ 0x00, 0x01, 0x00 }, { 0x00, 0x02, 0x00 }, { 0x00, 0x03, 0x00 },
+{ 0x00, 0x04, 0x00 }, { 0x00, 0x05, 0x00 }, { 0x01, 0x03, 0x20 },
+{ 0x01, 0x04, 0x00 }, { 0x01, 0x05, 0x00 }, { 0x01, 0x06, 0x00 },
+{ 0x01, 0x07, 0x00 }, { 0x01, 0x08, 0x00 }, { 0x01, 0x09, 0x00 },
+{ 0x01, 0x0A, 0x00 }, { 0x01, 0x0B, 0x00 }, { 0x01, 0x0C, 0x00 },
+{ 0x01, 0x0D, 0x00 }, { 0x01, 0x0E, 0x00 }, { 0x02, 0x09, 0x20 },
+{ 0x02, 0x0A, 0x00 }, { 0x02, 0x0B, 0x00 }, { 0x02, 0x0C, 0x00 },
+{ 0x02, 0x0D, 0x00 }, { 0x02, 0x0E, 0x00 }, { 0x02, 0x0F, 0x00 },
+{ 0x02, 0x10, 0x00 }, { 0x02, 0x2B, 0x20 }, { 0x02, 0x2C, 0x00 },
+{ 0x04, 0x27, 0x20 }, { 0x04, 0x28, 0x00 }, { 0x04, 0x29, 0x00 },
+{ 0x04, 0x2A, 0x00 }, { 0x04, 0x2B, 0x00 }, { 0x24, 0x21, 0x20 },
+{ 0x24, 0x22, 0x00 }, { 0x44, 0x20, 0x20 }, { 0x44, 0x21, 0x00 },
+{ 0x44, 0x22, 0x00 }, { 0x44, 0x23, 0x00 }, { 0x44, 0x24, 0x00 },
+{ 0x44, 0x25, 0x00 }, { 0x44, 0x26, 0x00 }, { 0x44, 0x27, 0x00 },
+{ 0x44, 0x28, 0x00 }, { 0x44, 0x29, 0x00 }, { 0x44, 0x2A, 0x00 },
+{ 0x44, 0x2B, 0x00 }, { 0x44, 0x2C, 0x00 }, { 0x44, 0x2D, 0x00 },
+{ 0x44, 0x2E, 0x00 }, { 0x44, 0x2F, 0x00 }, { 0x44, 0x30, 0x00 },
+{ 0x44, 0x31, 0x00 }, { 0x64, 0x2E, 0x20 }, { 0x64, 0x2F, 0x00 },
+{ 0x64, 0x30, 0x00 }, { 0x64, 0x31, 0x00 }, { 0x64, 0x32, 0x00 },
+{ 0x64, 0x33, 0x00 }, { 0x64, 0x34, 0x00 }, { 0x64, 0x35, 0x00 },
+{ 0x64, 0x36, 0x00 }, { 0x64, 0x37, 0x00 }, { 0x64, 0x38, 0x00 },
+{ 0x65, 0x38, 0x20 }, { 0x66, 0x38, 0x20 }, { 0x67, 0x38, 0x20 },
+{ 0x68, 0x38, 0x20 }, { 0x69, 0x38, 0x20 }, { 0x6A, 0x38, 0x20 },
+{ 0x6B, 0x38, 0x20 }, { 0x6C, 0x38, 0x20 }, { 0x6D, 0x38, 0x20 },
+{ 0x6E, 0x38, 0x20 }, { 0x6F, 0x38, 0x20 } };
 
 
-boost::uint8_t gain_table_4000mhz_to_6000mhz[77][5] = { {0,0x00,0x00,0x20,1},
-    {1,0x00,0x00,0x00,0}, {2,0x00,0x00,0x00,0}, {3,0x00,0x00,0x00,0},
-    {4,0x00,0x00,0x00,0}, {5,0x00,0x01,0x00,0}, {6,0x00,0x02,0x00,0},
-    {7,0x00,0x03,0x00,0}, {8,0x01,0x01,0x20,1}, {9,0x01,0x02,0x00,0},
-    {10,0x01,0x03,0x00,0}, {11,0x01,0x04,0x20,1}, {12,0x01,0x05,0x00,0},
-    {13,0x01,0x06,0x00,0}, {14,0x01,0x07,0x00,0}, {15,0x01,0x08,0x00,0},
-    {16,0x01,0x09,0x00,0}, {17,0x01,0x0A,0x00,0}, {18,0x01,0x0B,0x00,0},
-    {19,0x01,0x0C,0x00,0}, {20,0x02,0x08,0x20,1}, {21,0x02,0x09,0x00,0},
-    {22,0x02,0x0A,0x00,0}, {23,0x02,0x0B,0x20,1}, {24,0x02,0x0C,0x00,0},
-    {25,0x02,0x0D,0x00,0}, {26,0x02,0x0E,0x00,0}, {27,0x02,0x0F,0x00,0},
-    {28,0x02,0x2A,0x20,1}, {29,0x02,0x2B,0x00,0}, {30,0x04,0x27,0x20,1},
-    {31,0x04,0x28,0x00,0}, {32,0x04,0x29,0x00,0}, {33,0x04,0x2A,0x00,0},
-    {34,0x04,0x2B,0x00,0}, {35,0x04,0x2C,0x00,0}, {36,0x04,0x2D,0x00,0},
-    {37,0x24,0x20,0x20,1}, {38,0x24,0x21,0x00,0}, {39,0x24,0x22,0x00,0},
-    {40,0x44,0x20,0x20,1}, {41,0x44,0x21,0x00,0}, {42,0x44,0x22,0x00,0},
-    {43,0x44,0x23,0x00,0}, {44,0x44,0x24,0x00,0}, {45,0x44,0x25,0x00,0},
-    {46,0x44,0x26,0x00,0}, {47,0x44,0x27,0x00,0}, {48,0x44,0x28,0x00,0},
-    {49,0x44,0x29,0x00,0}, {50,0x44,0x2A,0x00,0}, {51,0x44,0x2B,0x00,0},
-    {52,0x44,0x2C,0x00,0}, {53,0x44,0x2D,0x00,0}, {54,0x44,0x2E,0x00,0},
-    {55,0x64,0x2E,0x20,1}, {56,0x64,0x2F,0x00,0}, {57,0x64,0x30,0x00,0},
-    {58,0x64,0x31,0x00,0}, {59,0x64,0x32,0x00,0}, {60,0x64,0x33,0x00,0},
-    {61,0x64,0x34,0x00,0}, {62,0x64,0x35,0x00,0}, {63,0x64,0x36,0x00,0},
-    {64,0x64,0x37,0x00,0}, {65,0x64,0x38,0x00,0}, {66,0x65,0x38,0x20,1},
-    {67,0x66,0x38,0x20,1}, {68,0x67,0x38,0x20,1}, {69,0x68,0x38,0x20,1},
-    {70,0x69,0x38,0x20,1}, {71,0x6A,0x38,0x20,1}, {72,0x6B,0x38,0x20,1},
-    {73,0x6C,0x38,0x20,1}, {74,0x6D,0x38,0x20,1}, {75,0x6E,0x38,0x20,1},
-    {76,0x6F,0x38,0x20,1}};
+boost::uint8_t gain_table_4000mhz_to_6000mhz[77][3] = {
+{ 0x00, 0x00, 0x20 }, { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 },
+{ 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x00 }, { 0x00, 0x01, 0x00 },
+{ 0x00, 0x02, 0x00 }, { 0x00, 0x03, 0x00 }, { 0x01, 0x01, 0x20 },
+{ 0x01, 0x02, 0x00 }, { 0x01, 0x03, 0x00 }, { 0x01, 0x04, 0x20 },
+{ 0x01, 0x05, 0x00 }, { 0x01, 0x06, 0x00 }, { 0x01, 0x07, 0x00 },
+{ 0x01, 0x08, 0x00 }, { 0x01, 0x09, 0x00 }, { 0x01, 0x0A, 0x00 },
+{ 0x01, 0x0B, 0x00 }, { 0x01, 0x0C, 0x00 }, { 0x02, 0x08, 0x20 },
+{ 0x02, 0x09, 0x00 }, { 0x02, 0x0A, 0x00 }, { 0x02, 0x0B, 0x20 },
+{ 0x02, 0x0C, 0x00 }, { 0x02, 0x0D, 0x00 }, { 0x02, 0x0E, 0x00 },
+{ 0x02, 0x0F, 0x00 }, { 0x02, 0x2A, 0x20 }, { 0x02, 0x2B, 0x00 },
+{ 0x04, 0x27, 0x20 }, { 0x04, 0x28, 0x00 }, { 0x04, 0x29, 0x00 },
+{ 0x04, 0x2A, 0x00 }, { 0x04, 0x2B, 0x00 }, { 0x04, 0x2C, 0x00 },
+{ 0x04, 0x2D, 0x00 }, { 0x24, 0x20, 0x20 }, { 0x24, 0x21, 0x00 },
+{ 0x24, 0x22, 0x00 }, { 0x44, 0x20, 0x20 }, { 0x44, 0x21, 0x00 },
+{ 0x44, 0x22, 0x00 }, { 0x44, 0x23, 0x00 }, { 0x44, 0x24, 0x00 },
+{ 0x44, 0x25, 0x00 }, { 0x44, 0x26, 0x00 }, { 0x44, 0x27, 0x00 },
+{ 0x44, 0x28, 0x00 }, { 0x44, 0x29, 0x00 }, { 0x44, 0x2A, 0x00 },
+{ 0x44, 0x2B, 0x00 }, { 0x44, 0x2C, 0x00 }, { 0x44, 0x2D, 0x00 },
+{ 0x44, 0x2E, 0x00 }, { 0x64, 0x2E, 0x20 }, { 0x64, 0x2F, 0x00 },
+{ 0x64, 0x30, 0x00 }, { 0x64, 0x31, 0x00 }, { 0x64, 0x32, 0x00 },
+{ 0x64, 0x33, 0x00 }, { 0x64, 0x34, 0x00 }, { 0x64, 0x35, 0x00 },
+{ 0x64, 0x36, 0x00 }, { 0x64, 0x37, 0x00 }, { 0x64, 0x38, 0x00 },
+{ 0x65, 0x38, 0x20 }, { 0x66, 0x38, 0x20 }, { 0x67, 0x38, 0x20 },
+{ 0x68, 0x38, 0x20 }, { 0x69, 0x38, 0x20 }, { 0x6A, 0x38, 0x20 },
+{ 0x6B, 0x38, 0x20 }, { 0x6C, 0x38, 0x20 }, { 0x6D, 0x38, 0x20 },
+{ 0x6E, 0x38, 0x20 }, { 0x6F, 0x38, 0x20 } };
 
 
 #endif /* INCLUDED_AD9361_GAIN_TABLES_HPP */
-- 
cgit v1.2.3


From be14725245cca756e19c48d84aedc54064e8706c Mon Sep 17 00:00:00 2001
From: Julian Arnold <julian.arnold@ettus.com>
Date: Thu, 5 Mar 2015 15:25:13 -0800
Subject: b2xx: AGC support

---
 host/lib/usrp/b200/b200_impl.cpp                   |  10 ++
 host/lib/usrp/common/ad9361_ctrl.cpp               |  21 +++
 host/lib/usrp/common/ad9361_ctrl.hpp               |   6 +
 .../usrp/common/ad9361_driver/ad9361_device.cpp    | 170 ++++++++++++++++++---
 host/lib/usrp/common/ad9361_driver/ad9361_device.h |  12 +-
 5 files changed, 195 insertions(+), 24 deletions(-)

(limited to 'host/lib/usrp/b200')

diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index ada25ad59..663696926 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -734,6 +734,16 @@ void b200_impl::setup_radio(const size_t dspno)
                 .set("RX2");
             _tree->create<sensor_value_t>(rf_fe_path / "sensors" / "rssi")
                 .publish(boost::bind(&ad9361_ctrl::get_rssi, _codec_ctrl, key));
+
+            //AGC setup
+            const std::list<std::string> mode_strings = boost::assign::list_of("slow")("fast");
+            _tree->create<bool>(rf_fe_path / "gain" / "agc" / "enable")
+                .subscribe(boost::bind((&ad9361_ctrl::set_agc), _codec_ctrl, key, _1))
+                .set(false);
+            _tree->create<std::string>(rf_fe_path / "gain" / "agc" / "mode" / "value")
+                .subscribe(boost::bind((&ad9361_ctrl::set_agc_mode), _codec_ctrl, key, _1)).set(mode_strings.front());
+            _tree->create<std::list<std::string> >(rf_fe_path / "gain" / "agc" / "mode" / "options")
+                            .set(mode_strings);
         }
         if (key[0] == 'T')
         {
diff --git a/host/lib/usrp/common/ad9361_ctrl.cpp b/host/lib/usrp/common/ad9361_ctrl.cpp
index ada74cda5..a0a5fa663 100644
--- a/host/lib/usrp/common/ad9361_ctrl.cpp
+++ b/host/lib/usrp/common/ad9361_ctrl.cpp
@@ -107,6 +107,27 @@ public:
         return _device.set_gain(direction, chain, value);
     }
 
+    void set_agc(const std::string &which, bool enable)
+    {
+        boost::lock_guard<boost::mutex> lock(_mutex);
+
+        ad9361_device_t::chain_t chain =_get_chain_from_antenna(which);
+         _device.set_agc(chain, enable);
+    }
+
+    void set_agc_mode(const std::string &which, const std::string &mode)
+    {
+        boost::lock_guard<boost::mutex> lock(_mutex);
+        ad9361_device_t::chain_t chain =_get_chain_from_antenna(which);
+        if(mode == "slow") {
+            _device.set_agc_mode(chain, ad9361_device_t::GAIN_MODE_SLOW_AGC);
+        } else if (mode == "fast"){
+            _device.set_agc_mode(chain, ad9361_device_t::GAIN_MODE_FAST_AGC);
+        } else {
+            throw uhd::runtime_error("ad9361_ctrl got an invalid AGC option.");
+        }
+    }
+
     //! set a new clock rate, return the exact value
     double set_clock_rate(const double rate)
     {
diff --git a/host/lib/usrp/common/ad9361_ctrl.hpp b/host/lib/usrp/common/ad9361_ctrl.hpp
index 5396de225..0dd1b08d9 100644
--- a/host/lib/usrp/common/ad9361_ctrl.hpp
+++ b/host/lib/usrp/common/ad9361_ctrl.hpp
@@ -88,6 +88,12 @@ public:
     //! set the gain for a particular gain element
     virtual double set_gain(const std::string &which, const double value) = 0;
 
+    //! Enable or disable the AGC module
+    virtual void set_agc(const std::string &which, bool enable) = 0;
+
+    //! configure the AGC module to slow or fast mode
+    virtual void set_agc_mode(const std::string &which, const std::string &mode) = 0;
+
     //! set a new clock rate, return the exact value
     virtual double set_clock_rate(const double rate) = 0;
 
diff --git a/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp b/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp
index e5938184c..ba66769dd 100644
--- a/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp
+++ b/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp
@@ -945,28 +945,58 @@ void ad9361_device_t::_program_gain_table() {
 
 /* Setup gain control registers.
  *
- * This really only needs to be done once, at initialization. */
-void ad9361_device_t::_setup_gain_control()
+ * This really only needs to be done once, at initialization.
+ * If AGC is used the mode select bits (Reg 0x0FA) must be written manually */
+void ad9361_device_t::_setup_gain_control(bool agc)
 {
-    _io_iface->poke8(0x0FA, 0xE0); // Gain Control Mode Select
-    _io_iface->poke8(0x0FB, 0x08); // Table, Digital Gain, Man Gain Ctrl
-    _io_iface->poke8(0x0FC, 0x23); // Incr Step Size, ADC Overrange Size
-    _io_iface->poke8(0x0FD, 0x4C); // Max Full/LMT Gain Table Index
-    _io_iface->poke8(0x0FE, 0x44); // Decr Step Size, Peak Overload Time
-    _io_iface->poke8(0x100, 0x6F); // Max Digital Gain
-    _io_iface->poke8(0x104, 0x2F); // ADC Small Overload Threshold
-    _io_iface->poke8(0x105, 0x3A); // ADC Large Overload Threshold
-    _io_iface->poke8(0x107, 0x31); // Large LMT Overload Threshold
-    _io_iface->poke8(0x108, 0x39); // Small LMT Overload Threshold
-    _io_iface->poke8(0x109, 0x23); // Rx1 Full/LMT Gain Index
-    _io_iface->poke8(0x10A, 0x58); // Rx1 LPF Gain Index
-    _io_iface->poke8(0x10B, 0x00); // Rx1 Digital Gain Index
-    _io_iface->poke8(0x10C, 0x23); // Rx2 Full/LMT Gain Index
-    _io_iface->poke8(0x10D, 0x18); // Rx2 LPF Gain Index
-    _io_iface->poke8(0x10E, 0x00); // Rx2 Digital Gain Index
-    _io_iface->poke8(0x114, 0x30); // Low Power Threshold
-    _io_iface->poke8(0x11A, 0x27); // Initial LMT Gain Limit
-    _io_iface->poke8(0x081, 0x00); // Tx Symbol Gain Control
+    /* The AGC mode configuration should be good for all cases.
+     * However, non AGC configuration still used for backward compatibility. */
+    if (agc) {
+        /*mode select bits must be written before hand!*/
+        _io_iface->poke8(0x0FB, 0x08); // Table, Digital Gain, Man Gain Ctrl
+        _io_iface->poke8(0x0FC, 0x23); // Incr Step Size, ADC Overrange Size
+        _io_iface->poke8(0x0FD, 0x4C); // Max Full/LMT Gain Table Index
+        _io_iface->poke8(0x0FE, 0x44); // Decr Step Size, Peak Overload Time
+        _io_iface->poke8(0x100, 0x6F); // Max Digital Gain
+        _io_iface->poke8(0x101, 0x0A); // Max Digital Gain
+        _io_iface->poke8(0x103, 0x08); // Max Digital Gain
+        _io_iface->poke8(0x104, 0x2F); // ADC Small Overload Threshold
+        _io_iface->poke8(0x105, 0x3A); // ADC Large Overload Threshold
+        _io_iface->poke8(0x106, 0x22); // Max Digital Gain
+        _io_iface->poke8(0x107, 0x2B); // Large LMT Overload Threshold
+        _io_iface->poke8(0x108, 0x31);
+        _io_iface->poke8(0x111, 0x0A);
+        _io_iface->poke8(0x11A, 0x1C);
+        _io_iface->poke8(0x120, 0x0C);
+        _io_iface->poke8(0x121, 0x44);
+        _io_iface->poke8(0x122, 0x44);
+        _io_iface->poke8(0x123, 0x11);
+        _io_iface->poke8(0x124, 0xF5);
+        _io_iface->poke8(0x125, 0x3B);
+        _io_iface->poke8(0x128, 0x03);
+        _io_iface->poke8(0x129, 0x56);
+        _io_iface->poke8(0x12A, 0x22);
+    } else {
+        _io_iface->poke8(0x0FA, 0xE0); // Gain Control Mode Select
+        _io_iface->poke8(0x0FB, 0x08); // Table, Digital Gain, Man Gain Ctrl
+        _io_iface->poke8(0x0FC, 0x23); // Incr Step Size, ADC Overrange Size
+        _io_iface->poke8(0x0FD, 0x4C); // Max Full/LMT Gain Table Index
+        _io_iface->poke8(0x0FE, 0x44); // Decr Step Size, Peak Overload Time
+        _io_iface->poke8(0x100, 0x6F); // Max Digital Gain
+        _io_iface->poke8(0x104, 0x2F); // ADC Small Overload Threshold
+        _io_iface->poke8(0x105, 0x3A); // ADC Large Overload Threshold
+        _io_iface->poke8(0x107, 0x31); // Large LMT Overload Threshold
+        _io_iface->poke8(0x108, 0x39); // Small LMT Overload Threshold
+        _io_iface->poke8(0x109, 0x23); // Rx1 Full/LMT Gain Index
+        _io_iface->poke8(0x10A, 0x58); // Rx1 LPF Gain Index
+        _io_iface->poke8(0x10B, 0x00); // Rx1 Digital Gain Index
+        _io_iface->poke8(0x10C, 0x23); // Rx2 Full/LMT Gain Index
+        _io_iface->poke8(0x10D, 0x18); // Rx2 LPF Gain Index
+        _io_iface->poke8(0x10E, 0x00); // Rx2 Digital Gain Index
+        _io_iface->poke8(0x114, 0x30); // Low Power Threshold
+        _io_iface->poke8(0x11A, 0x27); // Initial LMT Gain Limit
+        _io_iface->poke8(0x081, 0x00); // Tx Symbol Gain Control
+    }
 }
 
 /* Setup the RX or TX synthesizers.
@@ -1421,6 +1451,10 @@ void ad9361_device_t::initialize()
     _tx2_gain = 0;
     _use_dc_offset_correction = true;
     _use_iq_balance_correction = true;
+    _rx1_agc_mode = GAIN_MODE_SLOW_AGC;
+    _rx2_agc_mode = GAIN_MODE_SLOW_AGC;
+    _rx1_agc_enable = false;
+    _rx2_agc_enable = false;
 
     /* Reset the device. */
     _io_iface->poke8(0x000, 0x01);
@@ -1564,7 +1598,7 @@ void ad9361_device_t::initialize()
 
     _program_mixer_gm_subtable();
     _program_gain_table();
-    _setup_gain_control();
+    _setup_gain_control(false);
 
     _calibrate_baseband_rx_analog_filter();
     _calibrate_baseband_tx_analog_filter();
@@ -1690,7 +1724,7 @@ double ad9361_device_t::set_clock_rate(const double req_rate)
 
     _program_mixer_gm_subtable();
     _program_gain_table();
-    _setup_gain_control();
+    _setup_gain_control(false);
     _reprogram_gains();
 
     _calibrate_baseband_rx_analog_filter();
@@ -2067,4 +2101,94 @@ void ad9361_device_t::set_iq_balance_auto(direction_t direction, const bool on)
     }
 }
 
+/* Sets the RX gain mode to be used.
+ * If a transition from an AGC to an non AGC mode occurs (or vice versa)
+ * the gain configuration will be reloaded. */
+void ad9361_device_t::_setup_agc(chain_t chain, gain_mode_t gain_mode)
+{
+    boost::uint8_t gain_mode_reg = 0;
+    boost::uint8_t gain_mode_prev = 0;
+    boost::uint8_t gain_mode_bits_pos = 0;
+
+    gain_mode_reg = _io_iface->peek8(0x0FA);
+    gain_mode_prev = (gain_mode_reg & 0x0F);
+
+    if (chain == CHAIN_1) {
+        gain_mode_bits_pos = 0;
+    } else if (chain == CHAIN_2) {
+        gain_mode_bits_pos = 2;
+    } else
+    {
+        throw uhd::runtime_error("[ad9361_device_t] Wrong value for chain");
+    }
+
+    gain_mode_reg = (gain_mode_reg & (~(0x03<<gain_mode_bits_pos))); //clear mode bits
+    switch (gain_mode) {
+        case GAIN_MODE_MANUAL:
+            //leave bits cleared
+            break;
+        case GAIN_MODE_SLOW_AGC:
+            gain_mode_reg = (gain_mode_reg | (0x02<<gain_mode_bits_pos));
+            break;
+        case GAIN_MODE_FAST_AGC:
+            gain_mode_reg = (gain_mode_reg | (0x01<<gain_mode_bits_pos));
+            break;
+        default:
+            throw uhd::runtime_error("[ad9361_device_t] Gain mode does not exist");
+    }
+    _io_iface->poke8(0x0FA, gain_mode_reg);
+    boost::uint8_t gain_mode_status = _io_iface->peek8(0x0FA);
+    gain_mode_status = (gain_mode_status & 0x0F);
+    /*Check if gain mode configuration needs to be reprogrammed*/
+    if (((gain_mode_prev == 0) && (gain_mode_status != 0)) || ((gain_mode_prev != 0) && (gain_mode_status == 0))) {
+        if (gain_mode_status == 0) {
+            /*load manual mode config*/
+            _setup_gain_control(false);
+        } else {
+            /*load agc mode config*/
+            _setup_gain_control(true);
+        }
+    }
+}
+
+void ad9361_device_t::set_agc(chain_t chain, bool enable)
+{
+    if(chain == CHAIN_1) {
+        _rx1_agc_enable = enable;
+        if(enable) {
+            _setup_agc(chain, _rx1_agc_mode);
+        } else {
+            _setup_agc(chain, GAIN_MODE_MANUAL);
+        }
+    } else if (chain == CHAIN_2){
+        _rx2_agc_enable = enable;
+        if(enable) {
+            _setup_agc(chain, _rx2_agc_mode);
+        } else {
+            _setup_agc(chain, GAIN_MODE_MANUAL);
+        }
+    } else
+    {
+        throw uhd::runtime_error("[ad9361_device_t] Wrong value for chain");
+    }
+}
+
+void ad9361_device_t::set_agc_mode(chain_t chain, gain_mode_t gain_mode)
+{
+    if(chain == CHAIN_1) {
+        _rx1_agc_mode = gain_mode;
+        if(_rx1_agc_enable) {
+            _setup_agc(chain, _rx1_agc_mode);
+        }
+    } else if(chain == CHAIN_2){
+        _rx2_agc_mode = gain_mode;
+        if(_rx2_agc_enable) {
+            _setup_agc(chain, _rx2_agc_mode);
+        }
+    } else
+    {
+        throw uhd::runtime_error("[ad9361_device_t] Wrong value for chain");
+    }
+}
+
 }}
diff --git a/host/lib/usrp/common/ad9361_driver/ad9361_device.h b/host/lib/usrp/common/ad9361_driver/ad9361_device.h
index 93dc413d5..1cfff9971 100644
--- a/host/lib/usrp/common/ad9361_driver/ad9361_device.h
+++ b/host/lib/usrp/common/ad9361_driver/ad9361_device.h
@@ -16,6 +16,7 @@ class ad9361_device_t : public boost::noncopyable
 public:
     enum direction_t { RX, TX };
     enum chain_t { CHAIN_1, CHAIN_2 };
+    enum gain_mode_t {GAIN_MODE_MANUAL, GAIN_MODE_SLOW_AGC, GAIN_MODE_FAST_AGC};
 
     ad9361_device_t(ad9361_params::sptr client, ad9361_io::sptr io_iface) :
         _client_params(client), _io_iface(io_iface) {}
@@ -78,6 +79,12 @@ public:
     /* Turn on/off AD9361's RX IQ imbalance correction */
     void set_iq_balance_auto(direction_t direction, const bool on);
 
+    /* Configure AD9361's AGC module to use either fast or slow AGC mode. */
+    void set_agc_mode(chain_t chain, gain_mode_t gain_mode);
+
+    /* Enable AD9361's AGC gain mode. */
+    void set_agc(chain_t chain, bool enable);
+
     //Constants
     static const double AD9361_MAX_GAIN;
     static const double AD9361_MAX_CLOCK_RATE;
@@ -101,7 +108,7 @@ private:    //Methods
     void _calibrate_tx_quadrature();
     void _program_mixer_gm_subtable();
     void _program_gain_table();
-    void _setup_gain_control();
+    void _setup_gain_control(bool use_agc);
     void _setup_synth(direction_t direction, double vcorate);
     double _tune_bbvco(const double rate);
     void _reprogram_gains();
@@ -109,6 +116,7 @@ private:    //Methods
     double _setup_rates(const double rate);
     double _get_temperature(const double cal_offset, const double timeout = 0.1);
     void _configure_bb_rf_dc_tracking(const bool on);
+    void _setup_agc(chain_t chain, gain_mode_t gain_mode);
 
 private:    //Members
     typedef struct {
@@ -133,6 +141,8 @@ private:    //Members
     double              _rx1_gain, _rx2_gain, _tx1_gain, _tx2_gain;
     boost::int32_t      _tfir_factor;
     boost::int32_t      _rfir_factor;
+    gain_mode_t         _rx1_agc_mode, _rx2_agc_mode;
+    bool                _rx1_agc_enable, _rx2_agc_enable;
     //Register soft-copies
     chip_regs_t         _regs;
     //Synchronization
-- 
cgit v1.2.3


From d9241b78d32402093c37ab7ce2f4336699219ed4 Mon Sep 17 00:00:00 2001
From: Ian Buckley <github@ionconcepts.com>
Date: Mon, 9 Mar 2015 11:20:56 -0700
Subject: B200: UHD support for FPGPIO connector on REV6+ boards.

- GPIO on UART connector all board Revs
- Consolidated fpgpio_bitbang into fpgpio example and renamed it gpio
- Changed FP_GPIO readback address to match X300
---
 host/examples/CMakeLists.txt          |   2 +-
 host/examples/fpgpio.cpp              | 418 ------------------------------
 host/examples/gpio.cpp                | 462 ++++++++++++++++++++++++++++++++++
 host/lib/usrp/b200/b200_impl.cpp      |  35 ++-
 host/lib/usrp/b200/b200_impl.hpp      |   7 +-
 host/lib/usrp/b200/b200_regs.hpp      |   2 +
 host/lib/usrp/cores/gpio_core_200.hpp |   9 +-
 host/lib/usrp/e300/e300_impl.cpp      |  34 +--
 host/lib/usrp/e300/e300_impl.hpp      |   6 +-
 host/lib/usrp/x300/x300_impl.cpp      |  35 +--
 host/lib/usrp/x300/x300_impl.hpp      |   6 +-
 11 files changed, 555 insertions(+), 461 deletions(-)
 delete mode 100644 host/examples/fpgpio.cpp
 create mode 100644 host/examples/gpio.cpp

(limited to 'host/lib/usrp/b200')

diff --git a/host/examples/CMakeLists.txt b/host/examples/CMakeLists.txt
index 598e42302..92947d86c 100644
--- a/host/examples/CMakeLists.txt
+++ b/host/examples/CMakeLists.txt
@@ -35,7 +35,7 @@ SET(example_sources
     tx_waveforms.cpp
     txrx_loopback_to_file.cpp
     latency_test.cpp
-    fpgpio.cpp
+    gpio.cpp
 )
 
 IF(ENABLE_OCTOCLOCK)
diff --git a/host/examples/fpgpio.cpp b/host/examples/fpgpio.cpp
deleted file mode 100644
index c57893669..000000000
--- a/host/examples/fpgpio.cpp
+++ /dev/null
@@ -1,418 +0,0 @@
-//
-// Copyright 2014 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/>.
-//
-
-// Example for front panel GPIO.
-// Bits are set as follows:
-// FPGPIO[0] = ATR output 1 at idle
-// FPGPIO[1] = ATR output 1 during RX
-// FPGPIO[2] = ATR output 1 during TX
-// FPGPIO[3] = ATR output 1 during full duplex
-// FPGPIO[4] = output
-// FPGPIO[5] = input
-// FPGPIO[6] = input (X series only)
-// FPGPIO[7] = input (X series only)
-// FPGPIO[8] = input (X series only)
-// FPGPIO[9] = input (X series only)
-// FPGPIO[10] = input (X series only)
-// The example cycles through idle, TX, RX, and full duplex, spending 2 seconds for each.
-// Outputs can be physically looped back to inputs for verification testing.
-
-#include <uhd/utils/thread_priority.hpp>
-#include <uhd/utils/safe_main.hpp>
-#include <uhd/usrp/multi_usrp.hpp>
-#include <uhd/convert.hpp>
-#include <boost/program_options.hpp>
-#include <boost/format.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/thread.hpp>
-#include <csignal>
-#include <iostream>
-
-static const std::string FPGPIO_DEFAULT_CPU_FORMAT = "fc32";
-static const std::string FPGPIO_DEFAULT_OTW_FORMAT = "sc16";
-static const double      FPGPIO_DEFAULT_RX_RATE    = 500e3;
-static const double      FPGPIO_DEFAULT_TX_RATE    = 500e3;
-static const double      FPGPIO_DEFAULT_DWELL_TIME = 2.0;
-static const std::string FPGPIO_DEFAULT_GPIO       = "FP0";
-static const size_t      FPGPIO_DEFAULT_NUM_BITS   = 11;
-
-static UHD_INLINE boost::uint32_t FPGPIO_BIT(const size_t x)
-{
-    return (1 << x);
-}
-
-namespace po = boost::program_options;
-
-static bool stop_signal_called = false;
-void sig_int_handler(int){stop_signal_called = true;}
-
-std::string to_bit_string(boost::uint32_t val, const size_t num_bits)
-{
-    std::string out;
-    for (int i = num_bits - 1; i >= 0; i--)
-    {
-        std::string bit = ((val >> i) & 1) ? "1" : "0";
-        out += "  ";
-        out += bit;
-    }
-    return out;
-}
-
-void output_reg_values(
-    const std::string bank,
-    const uhd::usrp::multi_usrp::sptr &usrp,
-    const size_t num_bits)
-{
-    std::cout << (boost::format("Bit       "));
-    for (int i = num_bits - 1; i >= 0; i--)
-        std::cout << (boost::format(" %s%d") % (i < 10 ? " " : "") % i);
-    std::cout << std::endl;
-    std::cout << "CTRL:     " << to_bit_string(
-                                     boost::uint32_t(usrp->get_gpio_attr(bank, std::string("CTRL"))),
-                                     num_bits)
-                              << std::endl;
-
-    std::cout << "DDR:      " << to_bit_string(
-                                     boost::uint32_t(usrp->get_gpio_attr(bank, std::string("DDR"))),
-                                     num_bits)
-                              << std::endl;
-
-    std::cout << "ATR_0X:   " << to_bit_string(
-                                     boost::uint32_t(usrp->get_gpio_attr(bank, std::string("ATR_0X"))),
-                                     num_bits)
-                              << std::endl;
-
-    std::cout << "ATR_RX:   " << to_bit_string(
-                                     boost::uint32_t(usrp->get_gpio_attr(bank, std::string("ATR_RX"))),
-                                     num_bits)
-                              << std::endl;
-
-    std::cout << "ATR_TX:   " << to_bit_string(
-                                     boost::uint32_t(usrp->get_gpio_attr(bank, std::string("ATR_TX"))),
-                                     num_bits)
-                              << std::endl;
-
-    std::cout << "ATR_XX:   " << to_bit_string(
-                                     boost::uint32_t(usrp->get_gpio_attr(bank, std::string("ATR_XX"))),
-                                     num_bits)
-                              << std::endl;
-
-    std::cout << "OUT:      " << to_bit_string(
-                                     boost::uint32_t(usrp->get_gpio_attr(bank, std::string("OUT"))),
-                                     num_bits)
-                              << std::endl;
-
-    std::cout << "READBACK: " << to_bit_string(
-                                     boost::uint32_t(usrp->get_gpio_attr(bank, std::string("READBACK"))),
-                                     num_bits)
-                              << std::endl;
-}
-
-int UHD_SAFE_MAIN(int argc, char *argv[])
-{
-    uhd::set_thread_priority_safe();
-
-    //variables to be set by po
-    std::string args;
-    std::string cpu, otw;
-    double rx_rate, tx_rate, dwell;
-    std::string fpgpio;
-    size_t num_bits;
-
-    //setup the program options
-    po::options_description desc("Allowed options");
-    desc.add_options()
-        ("help", "help message")
-        ("args", po::value<std::string>(&args)->default_value(""), "multi uhd device address args")
-        ("repeat", "repeat loop until Ctrl-C is pressed")
-        ("cpu", po::value<std::string>(&cpu)->default_value(FPGPIO_DEFAULT_CPU_FORMAT), "cpu data format")
-        ("otw", po::value<std::string>(&otw)->default_value(FPGPIO_DEFAULT_OTW_FORMAT), "over the wire data format")
-        ("rx_rate", po::value<double>(&rx_rate)->default_value(FPGPIO_DEFAULT_RX_RATE), "rx sample rate")
-        ("tx_rate", po::value<double>(&tx_rate)->default_value(FPGPIO_DEFAULT_TX_RATE), "tx sample rate")
-        ("dwell", po::value<double>(&dwell)->default_value(FPGPIO_DEFAULT_DWELL_TIME), "dwell time in seconds for each test case")
-        ("gpio", po::value<std::string>(&fpgpio)->default_value(FPGPIO_DEFAULT_GPIO), "name of gpio bank")
-        ("bits", po::value<size_t>(&num_bits)->default_value(FPGPIO_DEFAULT_NUM_BITS), "number of bits in gpio bank")
-    ;
-    po::variables_map vm;
-    po::store(po::parse_command_line(argc, argv, desc), vm);
-    po::notify(vm);
-
-    //print the help message
-    if (vm.count("help")){
-        std::cout << boost::format("Front Panel GPIO %s") % desc << std::endl;
-        return ~0;
-    }
-
-    //create a usrp device
-    std::cout << std::endl;
-    std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl;
-    uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);
-    std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl;
-
-    //print out initial unconfigured state of FP GPIO
-    std::cout << "Unconfigured GPIO values:" << std::endl;
-    output_reg_values(fpgpio, usrp, num_bits);
-
-    //configure GPIO registers
-    boost::uint32_t ctrl = 0;      // default all as manual
-    boost::uint32_t ddr = 0;       // default all as input
-    boost::uint32_t atr_idle = 0;
-    boost::uint32_t atr_rx = 0;
-    boost::uint32_t atr_tx = 0;
-    boost::uint32_t atr_duplex = 0;
-    boost::uint32_t mask = 0x7ff;
-
-    //set up FPGPIO outputs:
-    //FPGPIO[0] = ATR output 1 at idle
-    ctrl |= FPGPIO_BIT(0);
-    atr_idle |= FPGPIO_BIT(0);
-    ddr |= FPGPIO_BIT(0);
-
-    //FPGPIO[1] = ATR output 1 during RX
-    ctrl |= FPGPIO_BIT(1);
-    ddr |= FPGPIO_BIT(1);
-    atr_rx |= FPGPIO_BIT(1);
-
-    //FPGPIO[2] = ATR output 1 during TX
-    ctrl |= FPGPIO_BIT(2);
-    ddr |= FPGPIO_BIT(2);
-    atr_tx |= FPGPIO_BIT(2);
-
-    //FPGPIO[3] = ATR output 1 during full duplex
-    ctrl |= FPGPIO_BIT(3);
-    ddr |= FPGPIO_BIT(3);
-    atr_duplex |= FPGPIO_BIT(3);
-
-    //FPGPIO[4] = output
-    ddr |= FPGPIO_BIT(4);
-
-    //set data direction register (DDR)
-    usrp->set_gpio_attr(fpgpio, std::string("DDR"), ddr, mask);
-
-    //set ATR registers
-    usrp->set_gpio_attr(fpgpio, std::string("ATR_0X"), atr_idle, mask);
-    usrp->set_gpio_attr(fpgpio, std::string("ATR_RX"), atr_rx, mask);
-    usrp->set_gpio_attr(fpgpio, std::string("ATR_TX"), atr_tx, mask);
-    usrp->set_gpio_attr(fpgpio, std::string("ATR_XX"), atr_duplex, mask);
-
-    //set control register
-    usrp->set_gpio_attr(fpgpio, std::string("CTRL"), ctrl, mask);
-
-    //print out initial state of FP GPIO
-    std::cout << "\nConfigured GPIO values:" << std::endl;
-    output_reg_values(fpgpio, usrp, num_bits);
-    std::cout << std::endl;
-
-    //set up streams
-    uhd::stream_args_t rx_args(cpu, otw);
-    uhd::stream_args_t tx_args(cpu, otw);
-    uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(rx_args);
-    uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(tx_args);
-    uhd::stream_cmd_t rx_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
-    rx_cmd.stream_now = true;
-    usrp->set_rx_rate(rx_rate);
-    usrp->set_tx_rate(tx_rate);
-
-    //set up buffers for tx and rx
-    const size_t max_samps_per_packet = rx_stream->get_max_num_samps();
-    const size_t nsamps_per_buff = max_samps_per_packet;
-    std::vector<char> rx_buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(cpu));
-    std::vector<char> tx_buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(cpu));
-    std::vector<void *> rx_buffs, tx_buffs;
-    for (size_t ch = 0; ch < rx_stream->get_num_channels(); ch++)
-        rx_buffs.push_back(&rx_buff.front()); //same buffer for each channel
-    for (size_t ch = 0; ch < tx_stream->get_num_channels(); ch++)
-        tx_buffs.push_back(&tx_buff.front()); //same buffer for each channel
-
-    uhd::rx_metadata_t rx_md;
-    uhd::tx_metadata_t tx_md;
-    tx_md.has_time_spec = false;
-    tx_md.start_of_burst = true;
-    uhd::time_spec_t stop_time;
-    double timeout = 0.01;
-    uhd::time_spec_t dwell_time(dwell);
-    int loop = 0;
-    boost::uint32_t rb, expected;
-
-    //register singal handler
-    std::signal(SIGINT, &sig_int_handler);
-
-    //Test the mask - only need to test once with no dwell time
-    std::cout << "\nTesting mask..." << std::flush;
-    //send a value of all 1's to the DDR with a mask for only bit 10
-    usrp->set_gpio_attr(fpgpio, std::string("DDR"), ~0, FPGPIO_BIT(10));
-    //bit 10 should now be 1, but all the other bits should be unchanged
-    rb = usrp->get_gpio_attr(fpgpio, std::string("DDR")) & mask;
-    expected = ddr | FPGPIO_BIT(10);
-    if (rb == expected)
-        std::cout << "pass" << std::endl;
-    else
-        std::cout << "fail" << std::endl;
-    std::cout << std::endl;
-    output_reg_values(fpgpio, usrp, num_bits);
-    usrp->set_gpio_attr(fpgpio, std::string("DDR"), ddr, mask);
-
-    while (not stop_signal_called)
-    {
-        int failures = 0;
-
-        if (vm.count("repeat"))
-            std::cout << "Press Ctrl + C to quit..." << std::endl;
-
-        // test user controlled GPIO and ATR idle by setting bit 4 high for 1 second
-        std::cout << "\nTesting user controlled GPIO and ATR idle output..." << std::flush;
-        usrp->set_gpio_attr(fpgpio, "OUT", 1 << 4, 1 << 4);
-        stop_time = usrp->get_time_now() + dwell_time;
-        while (not stop_signal_called and usrp->get_time_now() < stop_time)
-        {
-            boost::this_thread::sleep(boost::posix_time::milliseconds(100));
-        }
-        rb = usrp->get_gpio_attr(fpgpio, "READBACK");
-        expected = FPGPIO_BIT(4) | FPGPIO_BIT(0);
-        if ((rb & expected) != expected)
-        {
-            ++failures;
-            std::cout << "fail" << std::endl;
-            if ((rb & FPGPIO_BIT(0)) == 0)
-                std::cout << "Bit 0 should be set, but is not" << std::endl;
-            if ((rb & FPGPIO_BIT(4)) == 0)
-                std::cout << "Bit 4 should be set, but is not" << std::endl;
-        } else {
-            std::cout << "pass" << std::endl;
-        }
-        std::cout << std::endl;
-        output_reg_values(fpgpio, usrp, num_bits);
-        usrp->set_gpio_attr(fpgpio, "OUT", 0, FPGPIO_BIT(4));
-        if (stop_signal_called)
-            break;
-
-        // test ATR RX by receiving for 1 second
-        std::cout << "\nTesting ATR RX output..." << std::flush;
-        rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
-        rx_stream->issue_stream_cmd(rx_cmd);
-        stop_time = usrp->get_time_now() + dwell_time;
-        while (not stop_signal_called and usrp->get_time_now() < stop_time)
-        {
-            try {
-                rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
-            } catch(...){}
-        }
-        rb = usrp->get_gpio_attr(fpgpio, "READBACK");
-        expected = FPGPIO_BIT(1);
-        if ((rb & expected) != expected)
-        {
-            ++failures;
-            std::cout << "fail" << std::endl;
-            std::cout << "Bit 1 should be set, but is not" << std::endl;
-        } else {
-            std::cout << "pass" << std::endl;
-        }
-        std::cout << std::endl;
-        output_reg_values(fpgpio, usrp, num_bits);
-        rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
-        //clear out any data left in the rx stream
-        try {
-            rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
-        } catch(...){}
-        if (stop_signal_called)
-            break;
-
-        // test ATR TX by transmitting for 1 second
-        std::cout << "\nTesting ATR TX output..." << std::flush;
-        stop_time = usrp->get_time_now() + dwell_time;
-        tx_md.start_of_burst = true;
-        tx_md.end_of_burst = false;
-        while (not stop_signal_called and usrp->get_time_now() < stop_time)
-        {
-            try {
-                tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
-                tx_md.start_of_burst = false;
-            } catch(...){}
-        }
-        rb = usrp->get_gpio_attr(fpgpio, "READBACK");
-        expected = FPGPIO_BIT(2);
-        if ((rb & expected) != expected)
-        {
-            ++failures;
-            std::cout << "fail" << std::endl;
-            std::cout << "Bit 2 should be set, but is not" << std::endl;
-        } else {
-            std::cout << "pass" << std::endl;
-        }
-        std::cout << std::endl;
-        output_reg_values(fpgpio, usrp, num_bits);
-        tx_md.end_of_burst = true;
-        try {
-            tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
-        } catch(...){}
-        if (stop_signal_called)
-            break;
-
-        // test ATR RX by transmitting and receiving for 1 second
-        std::cout << "\nTesting ATR full duplex output..." << std::flush;
-        rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
-        rx_stream->issue_stream_cmd(rx_cmd);
-        tx_md.start_of_burst = true;
-        tx_md.end_of_burst = false;
-        stop_time = usrp->get_time_now() + dwell_time;
-        while (not stop_signal_called and usrp->get_time_now() < stop_time)
-        {
-            try {
-                tx_stream->send(rx_buffs, nsamps_per_buff, tx_md, timeout);
-                tx_md.start_of_burst = false;
-                rx_stream->recv(tx_buffs, nsamps_per_buff, rx_md, timeout);
-            } catch(...){}
-        }
-        rb = usrp->get_gpio_attr(fpgpio, "READBACK");
-        expected = FPGPIO_BIT(3);
-        if ((rb & expected) != expected)
-        {
-            ++failures;
-            std::cout << "fail" << std::endl;
-            std::cout << "Bit 3 should be set, but is not" << std::endl;
-        } else {
-            std::cout << "pass" << std::endl;
-        }
-        std::cout << std::endl;
-        output_reg_values(fpgpio, usrp, num_bits);
-        rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
-        tx_md.end_of_burst = true;
-        try {
-            tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
-        } catch(...){}
-        //clear out any data left in the rx stream
-        try {
-            rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
-        } catch(...){}
-
-        std::cout << std::endl;
-        if (failures)
-            std::cout << failures << " tests failed" << std::endl;
-        else
-            std::cout << "All tests passed!" << std::endl;
-
-        if (!vm.count("repeat"))
-            break;
-
-        std::cout << (boost::format("\nLoop %d completed")  % ++loop) << std::endl;
-    }
-
-    //finished
-    std::cout << std::endl << "Done!" << std::endl << std::endl;
-
-    return EXIT_SUCCESS;
-}
diff --git a/host/examples/gpio.cpp b/host/examples/gpio.cpp
new file mode 100644
index 000000000..b0d15f35a
--- /dev/null
+++ b/host/examples/gpio.cpp
@@ -0,0 +1,462 @@
+//
+// Copyright 2014-15 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/>.
+//
+
+// Example for GPIO testing and bit banging.
+//
+// This example was originally designed to test the 11 bit wide front panel
+// GPIO on the X300 series and has since been adapted to work with any GPIO
+// bank on any USRP and provide optional bit banging.  Please excuse the
+// clutter.  Also, there is no current way to detect the width of the
+// specified GPIO bank, so the user must specify the width with the --bits
+// flag if more than 11 bits.
+//
+// GPIO Testing:
+// For testing, GPIO bits are set as follows:
+// GPIO[0] = ATR output 1 at idle
+// GPIO[1] = ATR output 1 during RX
+// GPIO[2] = ATR output 1 during TX
+// GPIO[3] = ATR output 1 during full duplex
+// GPIO[4] = output
+// GPIO[n:5] = input (all other pins)
+// The testing cycles through idle, TX, RX, and full duplex, dwelling on each
+// test case (default 2 seconds), and then comparing the readback register with
+// the expected values of the outputs for verification.  The values of all GPIO
+// registers are displayed at the end of each test case.  Outputs can be
+// physically looped back to inputs to manually verify the inputs.
+//
+// GPIO Bit Banging:
+// GPIO banks have the standard registers of DDR for data direction and OUT
+// for output values.  Users can bit bang the GPIO bits by using this example
+// with the --bitbang flag and specifying the --ddr and --out flags to set the
+// values of the corresponding registers.  The READBACK register is
+// continuously read for the duration of the dwell time (default 2 seconds) so
+// users can monitor changes on the inputs.
+//
+// Automatic Transmit/Receive (ATR):
+// In addition to the standard DDR and OUT registers, the GPIO banks also
+// have ATR (Automatic Transmit/Receive) control registers that allow the
+// GPIO pins to be automatically set to specific values when the USRP is
+// idle, transmitting, receiving, or operating in full duplex mode.  The
+// description of these registers is below:
+// CTRL - Control (0=manual, 1=ATR)
+// ATR_0X - Values to be set when idle
+// ATR_RX - Output values to be set when receiving
+// ATR_TX - Output values to be set when transmitting
+// ATR_XX - Output values to be set when operating in full duplex
+// This code below contains examples of setting all these registers.  On
+// devices with multiple radios, the ATR for the front panel GPIO is driven
+// by the state of the first radio (0 or A).
+//
+// The UHD API
+// The multi_usrp::set_gpio_attr() method is the UHD API for configuring and
+// controlling the GPIO banks.  The parameters to the method are:
+// bank - the name of the GPIO bank (typically "FP0" for front panel GPIO,
+//                                   "TX<n>" for TX daughter card GPIO, or
+//                                   "RX<n>" for RX daughter card GPIO)
+// attr - attribute (register) to change ("DDR", "OUT", "CTRL", "ATR_0X",
+//                                        "ATR_RX", "ATR_TX", "ATR_XX")
+// value - the value to be set
+// mask - a mask indicating which bits in the specified attribute register are
+//          to be changed (default is all bits).
+
+#include <uhd/utils/thread_priority.hpp>
+#include <uhd/utils/safe_main.hpp>
+#include <uhd/usrp/multi_usrp.hpp>
+#include <uhd/convert.hpp>
+#include <boost/assign.hpp>
+#include <boost/program_options.hpp>
+#include <boost/format.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/thread.hpp>
+#include <csignal>
+#include <iostream>
+#include <stdlib.h>
+
+static const std::string        GPIO_DEFAULT_CPU_FORMAT = "fc32";
+static const std::string        GPIO_DEFAULT_OTW_FORMAT = "sc16";
+static const double             GPIO_DEFAULT_RX_RATE    = 500e3;
+static const double             GPIO_DEFAULT_TX_RATE    = 500e3;
+static const double             GPIO_DEFAULT_DWELL_TIME = 2.0;
+static const std::string        GPIO_DEFAULT_GPIO       = "FP0";
+static const size_t             GPIO_DEFAULT_NUM_BITS   = 11;
+static const std::string        GPIO_DEFAULT_CTRL       = "0x0";    // all as user controlled
+static const std::string        GPIO_DEFAULT_DDR        = "0x0";    // all as inputs
+static const std::string        GPIO_DEFAULT_OUT        = "0x0";
+
+static UHD_INLINE boost::uint32_t GPIO_BIT(const size_t x)
+{
+    return (1 << x);
+}
+
+namespace po = boost::program_options;
+
+static bool stop_signal_called = false;
+void sig_int_handler(int){stop_signal_called = true;}
+
+std::string to_bit_string(boost::uint32_t val, const size_t num_bits)
+{
+    std::string out;
+    for (int i = num_bits - 1; i >= 0; i--)
+    {
+        std::string bit = ((val >> i) & 1) ? "1" : "0";
+        out += "  ";
+        out += bit;
+    }
+    return out;
+}
+
+void output_reg_values(
+    const std::string bank,
+    const uhd::usrp::multi_usrp::sptr &usrp,
+    const size_t num_bits)
+{
+    std::vector<std::string> attrs = boost::assign::list_of("CTRL")("DDR")("ATR_0X")("ATR_RX")("ATR_TX")("ATR_XX")("OUT")("READBACK");
+    std::cout << (boost::format("%10s ") % "Bit");
+    for (int i = num_bits - 1; i >= 0; i--)
+        std::cout << (boost::format(" %2d") % i);
+    std::cout << std::endl;
+    BOOST_FOREACH(std::string &attr, attrs)
+    {
+        std::cout << (boost::format("%10s:%s")
+            % attr % to_bit_string(boost::uint32_t(usrp->get_gpio_attr(bank, attr)), num_bits))
+            << std::endl;
+    }
+}
+
+int UHD_SAFE_MAIN(int argc, char *argv[])
+{
+    uhd::set_thread_priority_safe();
+
+    //variables to be set by po
+    std::string args;
+    std::string cpu, otw;
+    double rx_rate, tx_rate, dwell;
+    std::string gpio;
+    size_t num_bits;
+    std::string ctrl_str;
+    std::string ddr_str;
+    std::string out_str;
+
+    //setup the program options
+    po::options_description desc("Allowed options");
+    desc.add_options()
+        ("help", "help message")
+        ("args", po::value<std::string>(&args)->default_value(""), "multi uhd device address args")
+        ("repeat", "repeat loop until Ctrl-C is pressed")
+        ("cpu", po::value<std::string>(&cpu)->default_value(GPIO_DEFAULT_CPU_FORMAT), "cpu data format")
+        ("otw", po::value<std::string>(&otw)->default_value(GPIO_DEFAULT_OTW_FORMAT), "over the wire data format")
+        ("rx_rate", po::value<double>(&rx_rate)->default_value(GPIO_DEFAULT_RX_RATE), "rx sample rate")
+        ("tx_rate", po::value<double>(&tx_rate)->default_value(GPIO_DEFAULT_TX_RATE), "tx sample rate")
+        ("dwell", po::value<double>(&dwell)->default_value(GPIO_DEFAULT_DWELL_TIME), "dwell time in seconds for each test case")
+        ("bank", po::value<std::string>(&gpio)->default_value(GPIO_DEFAULT_GPIO), "name of gpio bank")
+        ("bits", po::value<size_t>(&num_bits)->default_value(GPIO_DEFAULT_NUM_BITS), "number of bits in gpio bank")
+        ("bitbang", "single test case where user sets values for CTRL, DDR, and OUT registers")
+        ("ddr", po::value<std::string>(&ddr_str)->default_value(GPIO_DEFAULT_DDR), "GPIO DDR reg value")
+        ("out", po::value<std::string>(&out_str)->default_value(GPIO_DEFAULT_OUT), "GPIO OUT reg value")
+    ;
+    po::variables_map vm;
+    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::notify(vm);
+
+    //print the help message
+    if (vm.count("help")){
+        std::cout << boost::format("gpio %s") % desc << std::endl;
+        return ~0;
+    }
+
+    //create a usrp device
+    std::cout << std::endl;
+    std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl;
+    uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);
+    std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl;
+
+    //print out initial unconfigured state of FP GPIO
+    std::cout << "Initial GPIO values:" << std::endl;
+    output_reg_values(gpio, usrp, num_bits);
+
+    //configure GPIO registers
+    boost::uint32_t ddr = strtoul(ddr_str.c_str(), NULL, 0);
+    boost::uint32_t out = strtoul(out_str.c_str(), NULL, 0);
+    boost::uint32_t ctrl = 0;
+    boost::uint32_t atr_idle = 0;
+    boost::uint32_t atr_rx = 0;
+    boost::uint32_t atr_tx = 0;
+    boost::uint32_t atr_duplex = 0;
+    boost::uint32_t mask = (1 << num_bits) - 1;
+
+    if (!vm.count("bitbang"))
+    {
+        //set up GPIO outputs:
+        //GPIO[0] = ATR output 1 at idle
+        ctrl |= GPIO_BIT(0);
+        atr_idle |= GPIO_BIT(0);
+        ddr |= GPIO_BIT(0);
+
+        //GPIO[1] = ATR output 1 during RX
+        ctrl |= GPIO_BIT(1);
+        ddr |= GPIO_BIT(1);
+        atr_rx |= GPIO_BIT(1);
+
+        //GPIO[2] = ATR output 1 during TX
+        ctrl |= GPIO_BIT(2);
+        ddr |= GPIO_BIT(2);
+        atr_tx |= GPIO_BIT(2);
+
+        //GPIO[3] = ATR output 1 during full duplex
+        ctrl |= GPIO_BIT(3);
+        ddr |= GPIO_BIT(3);
+        atr_duplex |= GPIO_BIT(3);
+
+        //GPIO[4] = output
+        ddr |= GPIO_BIT(4);
+    }
+
+    //set data direction register (DDR)
+    usrp->set_gpio_attr(gpio, "DDR", ddr, mask);
+
+    //set output values (OUT)
+    usrp->set_gpio_attr(gpio, "OUT", out, mask);
+
+    //set ATR registers
+    usrp->set_gpio_attr(gpio, "ATR_0X", atr_idle, mask);
+    usrp->set_gpio_attr(gpio, "ATR_RX", atr_rx, mask);
+    usrp->set_gpio_attr(gpio, "ATR_TX", atr_tx, mask);
+    usrp->set_gpio_attr(gpio, "ATR_XX", atr_duplex, mask);
+
+    //set control register
+    usrp->set_gpio_attr(gpio, "CTRL", ctrl, mask);
+
+    //print out initial state of FP GPIO
+    std::cout << "\nConfigured GPIO values:" << std::endl;
+    output_reg_values(gpio, usrp, num_bits);
+    std::cout << std::endl;
+
+    //set up streams
+    uhd::stream_args_t rx_args(cpu, otw);
+    uhd::stream_args_t tx_args(cpu, otw);
+    uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(rx_args);
+    uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(tx_args);
+    uhd::stream_cmd_t rx_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
+    rx_cmd.stream_now = true;
+    usrp->set_rx_rate(rx_rate);
+    usrp->set_tx_rate(tx_rate);
+
+    //set up buffers for tx and rx
+    const size_t max_samps_per_packet = rx_stream->get_max_num_samps();
+    const size_t nsamps_per_buff = max_samps_per_packet;
+    std::vector<char> rx_buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(cpu));
+    std::vector<char> tx_buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(cpu));
+    std::vector<void *> rx_buffs, tx_buffs;
+    for (size_t ch = 0; ch < rx_stream->get_num_channels(); ch++)
+        rx_buffs.push_back(&rx_buff.front()); //same buffer for each channel
+    for (size_t ch = 0; ch < tx_stream->get_num_channels(); ch++)
+        tx_buffs.push_back(&tx_buff.front()); //same buffer for each channel
+
+    uhd::rx_metadata_t rx_md;
+    uhd::tx_metadata_t tx_md;
+    tx_md.has_time_spec = false;
+    tx_md.start_of_burst = true;
+    uhd::time_spec_t stop_time;
+    double timeout = 0.01;
+    uhd::time_spec_t dwell_time(dwell);
+    int loop = 0;
+    boost::uint32_t rb, expected;
+
+    //register signal handler
+    std::signal(SIGINT, &sig_int_handler);
+
+    if (!vm.count("bitbang"))
+    {
+        // Test the mask parameter of the multi_usrp::set_gpio_attr API
+        // We only need to test once with no dwell time
+        std::cout << "\nTesting mask..." << std::flush;
+        //send a value of all 1's to the DDR with a mask for only upper most bit
+        usrp->set_gpio_attr(gpio, "DDR", ~0, GPIO_BIT(num_bits - 1));
+        //upper most bit should now be 1, but all the other bits should be unchanged
+        rb = usrp->get_gpio_attr(gpio, "DDR") & mask;
+        expected = ddr | GPIO_BIT(num_bits - 1);
+        if (rb == expected)
+            std::cout << "pass:" << std::endl;
+        else
+            std::cout << "fail:" << std::endl;
+        output_reg_values(gpio, usrp, num_bits);
+        //restore DDR value
+        usrp->set_gpio_attr(gpio, "DDR", ddr, mask);
+    }
+
+    while (not stop_signal_called)
+    {
+        int failures = 0;
+
+        if (vm.count("repeat"))
+            std::cout << "Press Ctrl + C to quit..." << std::endl;
+
+        if (vm.count("bitbang"))
+        {
+            // dwell and continuously read back GPIO values
+            stop_time = usrp->get_time_now() + dwell_time;
+            while (not stop_signal_called and usrp->get_time_now() < stop_time)
+            {
+                rb = usrp->get_gpio_attr(gpio, "READBACK");
+                std::cout << "\rREADBACK: " << to_bit_string(rb, num_bits);
+                boost::this_thread::sleep(boost::posix_time::milliseconds(10));
+            }
+            std::cout << std::endl;
+        }
+        else
+        {
+            // test user controlled GPIO and ATR idle by setting bit 4 high for 1 second
+            std::cout << "\nTesting user controlled GPIO and ATR idle output..." << std::flush;
+            usrp->set_gpio_attr(gpio, "OUT", 1 << 4, 1 << 4);
+            stop_time = usrp->get_time_now() + dwell_time;
+            while (not stop_signal_called and usrp->get_time_now() < stop_time)
+            {
+                boost::this_thread::sleep(boost::posix_time::milliseconds(100));
+            }
+            rb = usrp->get_gpio_attr(gpio, "READBACK");
+            expected = GPIO_BIT(4) | GPIO_BIT(0);
+            if ((rb & expected) != expected)
+            {
+                ++failures;
+                std::cout << "fail:" << std::endl;
+                if ((rb & GPIO_BIT(0)) == 0)
+                    std::cout << "Bit 0 should be set, but is not" << std::endl;
+                if ((rb & GPIO_BIT(4)) == 0)
+                    std::cout << "Bit 4 should be set, but is not" << std::endl;
+            } else {
+                std::cout << "pass:" << std::endl;
+            }
+            output_reg_values(gpio, usrp, num_bits);
+            usrp->set_gpio_attr(gpio, "OUT", 0, GPIO_BIT(4));
+            if (stop_signal_called)
+                break;
+
+            // test ATR RX by receiving for 1 second
+            std::cout << "\nTesting ATR RX output..." << std::flush;
+            rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
+            rx_stream->issue_stream_cmd(rx_cmd);
+            stop_time = usrp->get_time_now() + dwell_time;
+            while (not stop_signal_called and usrp->get_time_now() < stop_time)
+            {
+                try {
+                    rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
+                } catch(...){}
+            }
+            rb = usrp->get_gpio_attr(gpio, "READBACK");
+            expected = GPIO_BIT(1);
+            if ((rb & expected) != expected)
+            {
+                ++failures;
+                std::cout << "fail:" << std::endl;
+                std::cout << "Bit 1 should be set, but is not" << std::endl;
+            } else {
+                std::cout << "pass:" << std::endl;
+            }
+            output_reg_values(gpio, usrp, num_bits);
+            rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
+            //clear out any data left in the rx stream
+            try {
+                rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
+            } catch(...){}
+            if (stop_signal_called)
+                break;
+
+            // test ATR TX by transmitting for 1 second
+            std::cout << "\nTesting ATR TX output..." << std::flush;
+            stop_time = usrp->get_time_now() + dwell_time;
+            tx_md.start_of_burst = true;
+            tx_md.end_of_burst = false;
+            while (not stop_signal_called and usrp->get_time_now() < stop_time)
+            {
+                try {
+                    tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
+                    tx_md.start_of_burst = false;
+                } catch(...){}
+            }
+            rb = usrp->get_gpio_attr(gpio, "READBACK");
+            expected = GPIO_BIT(2);
+            if ((rb & expected) != expected)
+            {
+                ++failures;
+                std::cout << "fail:" << std::endl;
+                std::cout << "Bit 2 should be set, but is not" << std::endl;
+            } else {
+                std::cout << "pass:" << std::endl;
+            }
+            output_reg_values(gpio, usrp, num_bits);
+            tx_md.end_of_burst = true;
+            try {
+                tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
+            } catch(...){}
+            if (stop_signal_called)
+                break;
+
+            // test ATR RX by transmitting and receiving for 1 second
+            std::cout << "\nTesting ATR full duplex output..." << std::flush;
+            rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
+            rx_stream->issue_stream_cmd(rx_cmd);
+            tx_md.start_of_burst = true;
+            tx_md.end_of_burst = false;
+            stop_time = usrp->get_time_now() + dwell_time;
+            while (not stop_signal_called and usrp->get_time_now() < stop_time)
+            {
+                try {
+                    tx_stream->send(rx_buffs, nsamps_per_buff, tx_md, timeout);
+                    tx_md.start_of_burst = false;
+                    rx_stream->recv(tx_buffs, nsamps_per_buff, rx_md, timeout);
+                } catch(...){}
+            }
+            rb = usrp->get_gpio_attr(gpio, "READBACK");
+            expected = GPIO_BIT(3);
+            if ((rb & expected) != expected)
+            {
+                ++failures;
+                std::cout << "fail:" << std::endl;
+                std::cout << "Bit 3 should be set, but is not" << std::endl;
+            } else {
+                std::cout << "pass:" << std::endl;
+            }
+            output_reg_values(gpio, usrp, num_bits);
+            rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
+            tx_md.end_of_burst = true;
+            try {
+                tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
+            } catch(...){}
+            //clear out any data left in the rx stream
+            try {
+                rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
+            } catch(...){}
+
+            std::cout << std::endl;
+            if (failures)
+                std::cout << failures << " tests failed" << std::endl;
+            else
+                std::cout << "All tests passed!" << std::endl;
+        }
+
+        if (!vm.count("repeat"))
+            break;
+
+        if (not stop_signal_called)
+            std::cout << (boost::format("\nLoop %d completed")  % ++loop) << std::endl;
+    }
+
+    //finished
+    std::cout << std::endl << "Done!" << std::endl << std::endl;
+
+    return EXIT_SUCCESS;
+}
diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index 663696926..89af6a6e1 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2012-2014 Ettus Research LLC
+// Copyright 2012-2015 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
@@ -528,6 +528,19 @@ b200_impl::b200_impl(const device_addr_t &device_addr)
     static const std::vector<std::string> clock_sources = boost::assign::list_of("internal")("external")("gpsdo");
     _tree->create<std::vector<std::string> >(mb_path / "clock_source" / "options").set(clock_sources);
 
+    ////////////////////////////////////////////////////////////////////
+    // front panel gpio
+    ////////////////////////////////////////////////////////////////////
+    _radio_perifs[0].fp_gpio = gpio_core_200::make(_radio_perifs[0].ctrl, TOREG(SR_FP_GPIO), RB32_FP_GPIO);
+    BOOST_FOREACH(const gpio_attr_map_t::value_type attr, gpio_attr_map)
+    {
+            _tree->create<boost::uint32_t>(mb_path / "gpio" / "FP0" / attr.second)
+            .set(0)
+            .subscribe(boost::bind(&b200_impl::set_fp_gpio, this, _radio_perifs[0].fp_gpio, attr.first, _1));
+    }
+    _tree->create<boost::uint32_t>(mb_path / "gpio" / "FP0" / "READBACK")
+        .publish(boost::bind(&b200_impl::get_fp_gpio, this, _radio_perifs[0].fp_gpio));
+
     ////////////////////////////////////////////////////////////////////
     // dboard eeproms but not really
     ////////////////////////////////////////////////////////////////////
@@ -902,6 +915,26 @@ void b200_impl::set_mb_eeprom(const uhd::usrp::mboard_eeprom_t &mb_eeprom)
 }
 
 
+boost::uint32_t b200_impl::get_fp_gpio(gpio_core_200::sptr gpio)
+{
+    return boost::uint32_t(gpio->read_gpio(dboard_iface::UNIT_RX));
+}
+
+void b200_impl::set_fp_gpio(gpio_core_200::sptr gpio, const gpio_attr_t attr, const boost::uint32_t value)
+{
+    switch (attr)
+    {
+    case CTRL:      return gpio->set_pin_ctrl(dboard_iface::UNIT_RX, value);
+    case DDR:       return gpio->set_gpio_ddr(dboard_iface::UNIT_RX, value);
+    case OUT:       return gpio->set_gpio_out(dboard_iface::UNIT_RX, value);
+    case ATR_0X:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, value);
+    case ATR_RX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, value);
+    case ATR_TX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, value);
+    case ATR_XX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, value);
+    default:        UHD_THROW_INVALID_CODE_PATH();
+    }
+}
+
 /***********************************************************************
  * Reference time and clock
  **********************************************************************/
diff --git a/host/lib/usrp/b200/b200_impl.hpp b/host/lib/usrp/b200/b200_impl.hpp
index 64d7aa7d0..cff767b4b 100644
--- a/host/lib/usrp/b200/b200_impl.hpp
+++ b/host/lib/usrp/b200/b200_impl.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2012-2013 Ettus Research LLC
+// Copyright 2012-2015 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
@@ -156,6 +156,7 @@ private:
     {
         radio_ctrl_core_3000::sptr ctrl;
         gpio_core_200_32wo::sptr atr;
+        gpio_core_200::sptr fp_gpio;
         time_core_3000::sptr time64;
         rx_vita_core_3000::sptr framer;
         rx_dsp_core_3000::sptr ddc;
@@ -194,6 +195,9 @@ private:
     void update_enables(void);
     void update_atrs(void);
 
+    boost::uint32_t get_fp_gpio(gpio_core_200::sptr);
+    void set_fp_gpio(gpio_core_200::sptr, const gpio_attr_t, const boost::uint32_t);
+
     double _tick_rate;
     double get_tick_rate(void){return _tick_rate;}
     double set_tick_rate(const double rate);
@@ -245,6 +249,7 @@ private:
     //! Coercer, attached to the "rate/value" property on the rx dsps.
     double coerce_rx_samp_rate(rx_dsp_core_3000::sptr, size_t, const double);
     void update_rx_samp_rate(const size_t, const double);
+
     //! Coercer, attached to the "rate/value" property on the tx dsps.
     double coerce_tx_samp_rate(tx_dsp_core_3000::sptr, size_t, const double);
     void update_tx_samp_rate(const size_t, const double);
diff --git a/host/lib/usrp/b200/b200_regs.hpp b/host/lib/usrp/b200/b200_regs.hpp
index 900651f94..8f2dd03f3 100644
--- a/host/lib/usrp/b200/b200_regs.hpp
+++ b/host/lib/usrp/b200/b200_regs.hpp
@@ -46,11 +46,13 @@ localparam SR_TX_DSP    = 184;
 localparam SR_TIME      = 128;
 localparam SR_RX_FMT    = 136;
 localparam SR_TX_FMT    = 138;
+localparam SR_FP_GPIO   = 200;
 
 localparam RB32_TEST            = 0;
 localparam RB64_TIME_NOW        = 8;
 localparam RB64_TIME_PPS        = 16;
 localparam RB64_CODEC_READBACK  = 24;
+localparam RB32_FP_GPIO         = 32;
 
 //pll constants
 static const int AD9361_SLAVENO = (1 << 0);
diff --git a/host/lib/usrp/cores/gpio_core_200.hpp b/host/lib/usrp/cores/gpio_core_200.hpp
index 164437f40..a76cced01 100644
--- a/host/lib/usrp/cores/gpio_core_200.hpp
+++ b/host/lib/usrp/cores/gpio_core_200.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2011,2014 Ettus Research LLC
+// Copyright 2011,2014,2015 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
@@ -20,10 +20,17 @@
 
 #include <uhd/config.hpp>
 #include <uhd/usrp/dboard_iface.hpp>
+#include <boost/assign.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/utility.hpp>
 #include <boost/shared_ptr.hpp>
 #include <uhd/types/wb_iface.hpp>
+#include <map>
+
+typedef enum{CTRL,DDR,OUT,ATR_0X,ATR_RX,ATR_TX,ATR_XX} gpio_attr_t;
+typedef std::map<gpio_attr_t,std::string> gpio_attr_map_t;
+static const gpio_attr_map_t gpio_attr_map =
+    boost::assign::map_list_of(CTRL,"CTRL")(DDR,"DDR")(OUT,"OUT")(ATR_0X,"ATR_0X")(ATR_RX,"ATR_RX")(ATR_TX,"ATR_TX")(ATR_XX,"ATR_XX");
 
 class gpio_core_200 : boost::noncopyable{
 public:
diff --git a/host/lib/usrp/e300/e300_impl.cpp b/host/lib/usrp/e300/e300_impl.cpp
index ce94147e8..ac92f9a12 100644
--- a/host/lib/usrp/e300/e300_impl.cpp
+++ b/host/lib/usrp/e300/e300_impl.cpp
@@ -469,15 +469,14 @@ e300_impl::e300_impl(const uhd::device_addr_t &device_addr)
     // internal gpios
     ////////////////////////////////////////////////////////////////////
     gpio_core_200::sptr fp_gpio = gpio_core_200::make(_radio_perifs[0].ctrl, TOREG(SR_FP_GPIO), RB32_FP_GPIO);
-    const std::vector<std::string> gpio_attrs = boost::assign::list_of("CTRL")("DDR")("OUT")("ATR_0X")("ATR_RX")("ATR_TX")("ATR_XX");
-    BOOST_FOREACH(const std::string &attr, gpio_attrs)
+    BOOST_FOREACH(const gpio_attr_map_t::value_type attr, gpio_attr_map)
     {
-        _tree->create<boost::uint32_t>(mb_path / "gpio" / "INT0" / attr)
-            .subscribe(boost::bind(&e300_impl::_set_internal_gpio, this, fp_gpio, attr, _1))
+        _tree->create<boost::uint32_t>(mb_path / "gpio" / "INT0" / attr.second)
+            .subscribe(boost::bind(&e300_impl::_set_internal_gpio, this, fp_gpio, attr.first, _1))
             .set(0);
     }
     _tree->create<boost::uint8_t>(mb_path / "gpio" / "INT0" / "READBACK")
-        .publish(boost::bind(&e300_impl::_get_internal_gpio, this, fp_gpio, "READBACK"));
+        .publish(boost::bind(&e300_impl::_get_internal_gpio, this, fp_gpio));
 
 
     ////////////////////////////////////////////////////////////////////
@@ -576,32 +575,35 @@ e300_impl::e300_impl(const uhd::device_addr_t &device_addr)
     _tree->access<subdev_spec_t>(mb_path / "tx_subdev_spec").set(tx_spec);
 }
 
-boost::uint8_t e300_impl::_get_internal_gpio(
-    gpio_core_200::sptr gpio,
-    const std::string &)
+boost::uint8_t e300_impl::_get_internal_gpio(gpio_core_200::sptr gpio)
 {
     return boost::uint32_t(gpio->read_gpio(dboard_iface::UNIT_RX));
 }
 
 void e300_impl::_set_internal_gpio(
     gpio_core_200::sptr gpio,
-    const std::string &attr,
+    const gpio_attr_t attr,
     const boost::uint32_t value)
 {
-    if (attr == "CTRL")
+    switch (attr)
+    {
+    case CTRL:
         return gpio->set_pin_ctrl(dboard_iface::UNIT_RX, value);
-    else if (attr == "DDR")
+    case DDR:
         return gpio->set_gpio_ddr(dboard_iface::UNIT_RX, value);
-    else if (attr == "OUT")
+    case OUT:
         return gpio->set_gpio_out(dboard_iface::UNIT_RX, value);
-    else if (attr == "ATR_0X")
+    case ATR_0X:
         return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, value);
-    else if (attr == "ATR_RX")
+    case ATR_RX:
         return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, value);
-    else if (attr == "ATR_TX")
+    case ATR_TX:
         return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, value);
-    else if (attr == "ATR_XX")
+    case ATR_XX:
         return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, value);
+    default:
+        UHD_THROW_INVALID_CODE_PATH();
+    }
 }
 
 uhd::sensor_value_t e300_impl::_get_fe_pll_lock(const bool is_tx)
diff --git a/host/lib/usrp/e300/e300_impl.hpp b/host/lib/usrp/e300/e300_impl.hpp
index c7d683f58..21aef215d 100644
--- a/host/lib/usrp/e300/e300_impl.hpp
+++ b/host/lib/usrp/e300/e300_impl.hpp
@@ -264,13 +264,11 @@ private: // methods
     uhd::sensor_value_t _get_fe_pll_lock(const bool is_tx);
 
     // internal gpios
-    boost::uint8_t _get_internal_gpio(
-        gpio_core_200::sptr,
-        const std::string &);
+    boost::uint8_t _get_internal_gpio(gpio_core_200::sptr);
 
     void _set_internal_gpio(
         gpio_core_200::sptr gpio,
-        const std::string &attr,
+        const gpio_attr_t attr,
         const boost::uint32_t value);
 
 private: // members
diff --git a/host/lib/usrp/x300/x300_impl.cpp b/host/lib/usrp/x300/x300_impl.cpp
index bf676b661..a82be543d 100644
--- a/host/lib/usrp/x300/x300_impl.cpp
+++ b/host/lib/usrp/x300/x300_impl.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2013-2014 Ettus Research LLC
+// Copyright 2013-2015 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
@@ -695,15 +695,14 @@ void x300_impl::setup_mb(const size_t mb_i, const uhd::device_addr_t &dev_addr)
     // front panel gpio
     ////////////////////////////////////////////////////////////////////
     mb.fp_gpio = gpio_core_200::make(mb.radio_perifs[0].ctrl, TOREG(SR_FP_GPIO), RB32_FP_GPIO);
-    const std::vector<std::string> GPIO_ATTRS = boost::assign::list_of("CTRL")("DDR")("OUT")("ATR_0X")("ATR_RX")("ATR_TX")("ATR_XX");
-    BOOST_FOREACH(const std::string &attr, GPIO_ATTRS)
+    BOOST_FOREACH(const gpio_attr_map_t::value_type attr, gpio_attr_map)
     {
-        _tree->create<boost::uint32_t>(mb_path / "gpio" / "FP0" / attr)
+        _tree->create<boost::uint32_t>(mb_path / "gpio" / "FP0" / attr.second)
             .set(0)
-            .subscribe(boost::bind(&x300_impl::set_fp_gpio, this, mb.fp_gpio, attr, _1));
+            .subscribe(boost::bind(&x300_impl::set_fp_gpio, this, mb.fp_gpio, attr.first, _1));
     }
     _tree->create<boost::uint32_t>(mb_path / "gpio" / "FP0" / "READBACK")
-        .publish(boost::bind(&x300_impl::get_fp_gpio, this, mb.fp_gpio, "READBACK"));
+        .publish(boost::bind(&x300_impl::get_fp_gpio, this, mb.fp_gpio));
 
     ////////////////////////////////////////////////////////////////////
     // register the time keepers - only one can be the highlander
@@ -1353,7 +1352,7 @@ void x300_impl::set_time_source_out(mboard_members_t &mb, const bool enb)
 void x300_impl::update_clock_source(mboard_members_t &mb, const std::string &source)
 {
     //Optimize for the case when the current source is internal and we are trying
-    //to set it to internal. This is the only case where we are guaranteed that 
+    //to set it to internal. This is the only case where we are guaranteed that
     //the clock has not gone away so we can skip setting the MUX and reseting the LMK.
     if (not (mb.current_refclk_src == "internal" and source == "internal")) {
         //Update the clock MUX on the motherboard to select the requested source
@@ -1534,20 +1533,24 @@ void x300_impl::set_mb_eeprom(i2c_iface::sptr i2c, const mboard_eeprom_t &mb_eep
  * front-panel GPIO
  **********************************************************************/
 
-boost::uint32_t x300_impl::get_fp_gpio(gpio_core_200::sptr gpio, const std::string &)
+boost::uint32_t x300_impl::get_fp_gpio(gpio_core_200::sptr gpio)
 {
     return boost::uint32_t(gpio->read_gpio(dboard_iface::UNIT_RX));
 }
 
-void x300_impl::set_fp_gpio(gpio_core_200::sptr gpio, const std::string &attr, const boost::uint32_t value)
+void x300_impl::set_fp_gpio(gpio_core_200::sptr gpio, const gpio_attr_t attr, const boost::uint32_t value)
 {
-    if (attr == "CTRL") return gpio->set_pin_ctrl(dboard_iface::UNIT_RX, value);
-    if (attr == "DDR") return gpio->set_gpio_ddr(dboard_iface::UNIT_RX, value);
-    if (attr == "OUT") return gpio->set_gpio_out(dboard_iface::UNIT_RX, value);
-    if (attr == "ATR_0X") return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, value);
-    if (attr == "ATR_RX") return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, value);
-    if (attr == "ATR_TX") return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, value);
-    if (attr == "ATR_XX") return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, value);
+    switch (attr)
+    {
+    case CTRL:      return gpio->set_pin_ctrl(dboard_iface::UNIT_RX, value);
+    case DDR:       return gpio->set_gpio_ddr(dboard_iface::UNIT_RX, value);
+    case OUT:       return gpio->set_gpio_out(dboard_iface::UNIT_RX, value);
+    case ATR_0X:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, value);
+    case ATR_RX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, value);
+    case ATR_TX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, value);
+    case ATR_XX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, value);
+    default:        UHD_THROW_INVALID_CODE_PATH();
+    }
 }
 
 /***********************************************************************
diff --git a/host/lib/usrp/x300/x300_impl.hpp b/host/lib/usrp/x300/x300_impl.hpp
index 70c5dccb4..9ad060c85 100644
--- a/host/lib/usrp/x300/x300_impl.hpp
+++ b/host/lib/usrp/x300/x300_impl.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2013-2014 Ettus Research LLC
+// Copyright 2013-2015 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
@@ -360,8 +360,8 @@ private:
     void check_fpga_compat(const uhd::fs_path &mb_path, uhd::wb_iface::sptr iface);
 
     void update_atr_leds(gpio_core_200_32wo::sptr, const std::string &ant);
-    boost::uint32_t get_fp_gpio(gpio_core_200::sptr, const std::string &);
-    void set_fp_gpio(gpio_core_200::sptr, const std::string &, const boost::uint32_t);
+    boost::uint32_t get_fp_gpio(gpio_core_200::sptr);
+    void set_fp_gpio(gpio_core_200::sptr, const gpio_attr_t, const boost::uint32_t);
 
     //**PRECONDITION**
     //This function assumes that all the VITA times in "radios" are synchronized
-- 
cgit v1.2.3


From 21ccefb2facf3e85d0ab7146a6d4b93782688ade Mon Sep 17 00:00:00 2001
From: Martin Braun <martin.braun@ettus.com>
Date: Wed, 11 Mar 2015 13:56:32 -0700
Subject: b200: Initialize _tick_rate properly to force tick rate update

---
 host/lib/usrp/b200/b200_impl.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'host/lib/usrp/b200')

diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index 13169a5ed..e30853762 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -196,7 +196,8 @@ UHD_STATIC_BLOCK(register_b200_device)
 /***********************************************************************
  * Structors
  **********************************************************************/
-b200_impl::b200_impl(const device_addr_t &device_addr)
+b200_impl::b200_impl(const device_addr_t &device_addr) :
+    _tick_rate(0.0) // Forces a clock initialization at startup
 {
     _tree = property_tree::make();
     _type = device::USRP;
-- 
cgit v1.2.3


From 08467564116f4b948620e831bfd4b5426a43611c Mon Sep 17 00:00:00 2001
From: Martin Braun <martin.braun@ettus.com>
Date: Wed, 11 Mar 2015 14:33:57 -0700
Subject: gpio: Renamed enums to avoid clash with generic, compiler-provided
 names

---
 host/lib/usrp/b200/b200_impl.cpp      | 14 +++++++-------
 host/lib/usrp/cores/gpio_core_200.hpp | 21 +++++++++++++++++++--
 host/lib/usrp/e300/e300_impl.cpp      | 14 +++++++-------
 host/lib/usrp/x300/x300_impl.cpp      | 14 +++++++-------
 4 files changed, 40 insertions(+), 23 deletions(-)

(limited to 'host/lib/usrp/b200')

diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index b1ab6ea7d..c22eb86bc 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -925,13 +925,13 @@ void b200_impl::set_fp_gpio(gpio_core_200::sptr gpio, const gpio_attr_t attr, co
 {
     switch (attr)
     {
-    case CTRL:      return gpio->set_pin_ctrl(dboard_iface::UNIT_RX, value);
-    case DDR:       return gpio->set_gpio_ddr(dboard_iface::UNIT_RX, value);
-    case OUT:       return gpio->set_gpio_out(dboard_iface::UNIT_RX, value);
-    case ATR_0X:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, value);
-    case ATR_RX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, value);
-    case ATR_TX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, value);
-    case ATR_XX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, value);
+    case GPIO_CTRL:   return gpio->set_pin_ctrl(dboard_iface::UNIT_RX, value);
+    case GPIO_DDR:    return gpio->set_gpio_ddr(dboard_iface::UNIT_RX, value);
+    case GPIO_OUT:    return gpio->set_gpio_out(dboard_iface::UNIT_RX, value);
+    case GPIO_ATR_0X: return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, value);
+    case GPIO_ATR_RX: return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, value);
+    case GPIO_ATR_TX: return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, value);
+    case GPIO_ATR_XX: return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, value);
     default:        UHD_THROW_INVALID_CODE_PATH();
     }
 }
diff --git a/host/lib/usrp/cores/gpio_core_200.hpp b/host/lib/usrp/cores/gpio_core_200.hpp
index a76cced01..e22834fd9 100644
--- a/host/lib/usrp/cores/gpio_core_200.hpp
+++ b/host/lib/usrp/cores/gpio_core_200.hpp
@@ -27,10 +27,27 @@
 #include <uhd/types/wb_iface.hpp>
 #include <map>
 
-typedef enum{CTRL,DDR,OUT,ATR_0X,ATR_RX,ATR_TX,ATR_XX} gpio_attr_t;
+typedef enum {
+    GPIO_CTRL,
+    GPIO_DDR,
+    GPIO_OUT,
+    GPIO_ATR_0X,
+    GPIO_ATR_RX,
+    GPIO_ATR_TX,
+    GPIO_ATR_XX
+} gpio_attr_t;
+
 typedef std::map<gpio_attr_t,std::string> gpio_attr_map_t;
 static const gpio_attr_map_t gpio_attr_map =
-    boost::assign::map_list_of(CTRL,"CTRL")(DDR,"DDR")(OUT,"OUT")(ATR_0X,"ATR_0X")(ATR_RX,"ATR_RX")(ATR_TX,"ATR_TX")(ATR_XX,"ATR_XX");
+    boost::assign::map_list_of
+        (GPIO_CTRL,   "CTRL")
+        (GPIO_DDR,    "DDR")
+        (GPIO_OUT,    "OUT")
+        (GPIO_ATR_0X, "ATR_0X")
+        (GPIO_ATR_RX, "ATR_RX")
+        (GPIO_ATR_TX, "ATR_TX")
+        (GPIO_ATR_XX, "ATR_XX")
+;
 
 class gpio_core_200 : boost::noncopyable{
 public:
diff --git a/host/lib/usrp/e300/e300_impl.cpp b/host/lib/usrp/e300/e300_impl.cpp
index ac92f9a12..8be3e47c9 100644
--- a/host/lib/usrp/e300/e300_impl.cpp
+++ b/host/lib/usrp/e300/e300_impl.cpp
@@ -587,19 +587,19 @@ void e300_impl::_set_internal_gpio(
 {
     switch (attr)
     {
-    case CTRL:
+    case GPIO_CTRL:
         return gpio->set_pin_ctrl(dboard_iface::UNIT_RX, value);
-    case DDR:
+    case GPIO_DDR:
         return gpio->set_gpio_ddr(dboard_iface::UNIT_RX, value);
-    case OUT:
+    case GPIO_OUT:
         return gpio->set_gpio_out(dboard_iface::UNIT_RX, value);
-    case ATR_0X:
+    case GPIO_ATR_0X:
         return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, value);
-    case ATR_RX:
+    case GPIO_ATR_RX:
         return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, value);
-    case ATR_TX:
+    case GPIO_ATR_TX:
         return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, value);
-    case ATR_XX:
+    case GPIO_ATR_XX:
         return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, value);
     default:
         UHD_THROW_INVALID_CODE_PATH();
diff --git a/host/lib/usrp/x300/x300_impl.cpp b/host/lib/usrp/x300/x300_impl.cpp
index a82be543d..d9b27b6b4 100644
--- a/host/lib/usrp/x300/x300_impl.cpp
+++ b/host/lib/usrp/x300/x300_impl.cpp
@@ -1542,13 +1542,13 @@ void x300_impl::set_fp_gpio(gpio_core_200::sptr gpio, const gpio_attr_t attr, co
 {
     switch (attr)
     {
-    case CTRL:      return gpio->set_pin_ctrl(dboard_iface::UNIT_RX, value);
-    case DDR:       return gpio->set_gpio_ddr(dboard_iface::UNIT_RX, value);
-    case OUT:       return gpio->set_gpio_out(dboard_iface::UNIT_RX, value);
-    case ATR_0X:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, value);
-    case ATR_RX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, value);
-    case ATR_TX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, value);
-    case ATR_XX:    return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, value);
+    case GPIO_CTRL:   return gpio->set_pin_ctrl(dboard_iface::UNIT_RX, value);
+    case GPIO_DDR:    return gpio->set_gpio_ddr(dboard_iface::UNIT_RX, value);
+    case GPIO_OUT:    return gpio->set_gpio_out(dboard_iface::UNIT_RX, value);
+    case GPIO_ATR_0X: return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, value);
+    case GPIO_ATR_RX: return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, value);
+    case GPIO_ATR_TX: return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, value);
+    case GPIO_ATR_XX: return gpio->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, value);
     default:        UHD_THROW_INVALID_CODE_PATH();
     }
 }
-- 
cgit v1.2.3


From fae746179cbb1d8ac146dcae9b5d6cb58b366a56 Mon Sep 17 00:00:00 2001
From: Martin Braun <martin.braun@ettus.com>
Date: Wed, 11 Mar 2015 16:14:00 -0700
Subject: uhd: Fixed multiple compiler warnings (unused variables, missing
 literal f)

---
 host/include/uhd/utils/math.hpp                  |  2 +-
 host/lib/usrp/b200/b200_impl.cpp                 |  2 +-
 host/lib/usrp/dboard/db_ubx.cpp                  |  2 +-
 host/lib/usrp/multi_usrp.cpp                     | 12 ++++++------
 host/lib/usrp_clock/octoclock/octoclock_impl.cpp |  2 +-
 host/utils/b2xx_fx3_utils.cpp                    |  4 ++--
 host/utils/query_gpsdo_sensors.cpp               |  2 +-
 7 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'host/lib/usrp/b200')

diff --git a/host/include/uhd/utils/math.hpp b/host/include/uhd/utils/math.hpp
index 21825c3dc..e6ac4d3dc 100644
--- a/host/include/uhd/utils/math.hpp
+++ b/host/include/uhd/utils/math.hpp
@@ -60,7 +60,7 @@ namespace math {
      * values, a custom epsilon should be defined for those computations. This
      * use-case is provided for in the `fp_compare_epsilon` class constructor.
      */
-    static const float SINGLE_PRECISION_EPSILON = 1.19e-7;
+    static const float SINGLE_PRECISION_EPSILON = 1.19e-7f;
     static const double DOUBLE_PRECISION_EPSILON = 2.22e-16;
 
 namespace fp_compare {
diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index e30853762..304a3fc48 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -1007,6 +1007,6 @@ sensor_value_t b200_impl::get_ref_locked(void)
 sensor_value_t b200_impl::get_fe_pll_locked(const bool is_tx)
 {
     const boost::uint32_t st = _local_ctrl->peek32(RB32_CORE_PLL);
-    const bool locked = is_tx ? st & 0x1 : st & 0x2;
+    const bool locked = is_tx ? bool(st & 0x1) : bool(st & 0x2);
     return sensor_value_t("LO", locked, "locked", "unlocked");
 }
diff --git a/host/lib/usrp/dboard/db_ubx.cpp b/host/lib/usrp/dboard/db_ubx.cpp
index b6cc1421c..5184d2ecb 100644
--- a/host/lib/usrp/dboard/db_ubx.cpp
+++ b/host/lib/usrp/dboard/db_ubx.cpp
@@ -84,7 +84,7 @@ protected:
         // Get only regs with changes
         try {
             changed_regs = get_changed_addrs();
-        } catch (uhd::runtime_error& e) {
+        } catch (uhd::runtime_error&) {
             // No saved state - write all regs
             for (int addr = 5; addr >= 0; addr--)
                 changed_regs.insert(boost::uint32_t(addr));
diff --git a/host/lib/usrp/multi_usrp.cpp b/host/lib/usrp/multi_usrp.cpp
index 175633c4c..45e736757 100644
--- a/host/lib/usrp/multi_usrp.cpp
+++ b/host/lib/usrp/multi_usrp.cpp
@@ -823,7 +823,7 @@ public:
     void set_rx_gain(double gain, const std::string &name, size_t chan){
         try {
             return rx_gain_group(chan)->set_value(gain, name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,rx);
         }
     }
@@ -831,7 +831,7 @@ public:
     double get_rx_gain(const std::string &name, size_t chan){
         try {
             return rx_gain_group(chan)->get_value(name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,rx);
         }
     }
@@ -839,7 +839,7 @@ public:
     gain_range_t get_rx_gain_range(const std::string &name, size_t chan){
         try {
             return rx_gain_group(chan)->get_range(name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,rx);
         }
     }
@@ -1024,7 +1024,7 @@ public:
     void set_tx_gain(double gain, const std::string &name, size_t chan){
         try {
             return tx_gain_group(chan)->set_value(gain, name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,tx);
         }
     }
@@ -1032,7 +1032,7 @@ public:
     double get_tx_gain(const std::string &name, size_t chan){
         try {
             return tx_gain_group(chan)->get_value(name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,tx);
         }
     }
@@ -1040,7 +1040,7 @@ public:
     gain_range_t get_tx_gain_range(const std::string &name, size_t chan){
         try {
             return tx_gain_group(chan)->get_range(name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,tx);
         }
     }
diff --git a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
index d55fab10e..b98d95725 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
@@ -417,7 +417,7 @@ std::string octoclock_impl::_get_images_help_message(const std::string &addr){
     try{
         image_location = uhd::find_image_path(image_name);
     }
-    catch(const std::exception &e){
+    catch(const std::exception &){
         return str(boost::format("Could not find %s in your images path.\n%s")
                    % image_name
                    % uhd::print_utility_error("uhd_images_downloader.py"));
diff --git a/host/utils/b2xx_fx3_utils.cpp b/host/utils/b2xx_fx3_utils.cpp
index 8b64be63e..572daef70 100644
--- a/host/utils/b2xx_fx3_utils.cpp
+++ b/host/utils/b2xx_fx3_utils.cpp
@@ -173,7 +173,7 @@ uhd::transport::usb_device_handle::sptr open_device(const boost::uint16_t vid, c
         if (!handle)
             std::cerr << "Cannot open device" << std::endl;
     }
-    catch(const std::exception &e) {
+    catch(const std::exception &) {
         std::cerr << "Failed to communicate with the device!" << std::endl;
         #ifdef UHD_PLATFORM_WIN32
         std::cerr << "The necessary drivers are not installed. Read the UHD Transport Application Notes for details:\nhttp://files.ettus.com/manual/page_transport.html" << std::endl;
@@ -195,7 +195,7 @@ b200_iface::sptr make_b200_iface(const uhd::transport::usb_device_handle::sptr &
         if (!b200)
             std::cerr << "Cannot create device interface" << std::endl;
     }
-    catch(const std::exception &e) {
+    catch(const std::exception &) {
         std::cerr << "Failed to communicate with the device!" << std::endl;
         #ifdef UHD_PLATFORM_WIN32
         std::cerr << "The necessary drivers are not installed. Read the UHD Transport Application Notes for details:\nhttp://files.ettus.com/manual/page_transport.html" << std::endl;
diff --git a/host/utils/query_gpsdo_sensors.cpp b/host/utils/query_gpsdo_sensors.cpp
index 05f918eb4..9a40d2b42 100644
--- a/host/utils/query_gpsdo_sensors.cpp
+++ b/host/utils/query_gpsdo_sensors.cpp
@@ -118,7 +118,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
       uhd::sensor_value_t rmc_string = usrp->get_mboard_sensor("gps_gprmc");
       std::cout << boost::format("Printing available NMEA strings:\n");
       std::cout << boost::format("%s\n%s\n%s\n") % gga_string.to_pp_string() % rmc_string.to_pp_string() % gps_time.to_pp_string();
-  } catch (std::exception &e) {
+  } catch (std::exception &) {
       std::cout << "NMEA strings not implemented for this device." << std::endl;
   }
   std::cout << boost::format("UHD Device time: %.0f seconds\n") % (last_pps_time.get_real_secs());
-- 
cgit v1.2.3