Merge branch 'master' of ettus.sourcerepo.com:ettus/uhdpriv into usrp2p-next

Conflicts:
	firmware/microblaze/lib/u2_init.c
	host/lib/usrp/usrp2/clock_ctrl.cpp
	host/lib/usrp/usrp2/fw_common.h
	host/lib/usrp/usrp2/mboard_impl.cpp
	host/lib/usrp/usrp2/usrp2_iface.cpp
	host/lib/usrp/usrp2/usrp2_iface.hpp

9 files changed, 594 insertions, 25 deletions

diff --git a/host/lib/usrp/dboard/CMakeLists.txt b/host/lib/usrp/dboard/CMakeLists.txt
index 8d3d11530..79cd42d18 100644
--- a/host/lib/usrp/dboard/CMakeLists.txt
+++ b/host/lib/usrp/dboard/CMakeLists.txt
@@ -25,5 +25,6 @@ LIBUHD_APPEND_SOURCES(
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard/db_dbsrx.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard/db_unknown.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard/db_tvrx.cpp
+    ${CMAKE_SOURCE_DIR}/lib/usrp/dboard/db_dbsrx2.cpp
 )
 
diff --git a/host/lib/usrp/dboard/db_basic_and_lf.cpp b/host/lib/usrp/dboard/db_basic_and_lf.cpp
index 41f6f8002..f03dd43d1 100644
--- a/host/lib/usrp/dboard/db_basic_and_lf.cpp
+++ b/host/lib/usrp/dboard/db_basic_and_lf.cpp
@@ -20,6 +20,7 @@
 #include <uhd/types/ranges.hpp>
 #include <uhd/utils/assert.hpp>
 #include <uhd/utils/static.hpp>
+#include <uhd/utils/warning.hpp>
 #include <uhd/usrp/dboard_base.hpp>
 #include <uhd/usrp/dboard_manager.hpp>
 #include <boost/assign/list_of.hpp>
@@ -30,6 +31,16 @@ using namespace uhd::usrp;
 using namespace boost::assign;
 
 /***********************************************************************
+ * Constants
+ **********************************************************************/
+static const uhd::dict<std::string, double> subdev_bandwidth_scalar = map_list_of
+    ("A", 1.0)
+    ("B", 1.0)
+    ("AB", 2.0)
+    ("BA", 2.0)
+;
+
+/***********************************************************************
  * The basic and lf boards:
  *   They share a common class because only the frequency bounds differ.
  **********************************************************************/
@@ -68,11 +79,11 @@ static const uhd::dict<std::string, subdev_conn_t> sd_name_to_conn = map_list_of
  * Register the basic and LF dboards
  **********************************************************************/
 static dboard_base::sptr make_basic_rx(dboard_base::ctor_args_t args){
-    return dboard_base::sptr(new basic_rx(args, 90e9));
+    return dboard_base::sptr(new basic_rx(args, 250e6));
 }
 
 static dboard_base::sptr make_basic_tx(dboard_base::ctor_args_t args){
-    return dboard_base::sptr(new basic_tx(args, 90e9));
+    return dboard_base::sptr(new basic_tx(args, 250e6));
 }
 
 static dboard_base::sptr make_lf_rx(dboard_base::ctor_args_t args){
@@ -161,6 +172,10 @@ void basic_rx::rx_get(const wax::obj &key_, wax::obj &val){
         val = true; //there is no LO, so it must be true!
         return;
 
+    case SUBDEV_PROP_BANDWIDTH:
+        val = subdev_bandwidth_scalar[get_subdev_name()]*_max_freq;
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -185,6 +200,14 @@ void basic_rx::rx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_ENABLED:
         return; //always enabled
 
+    case SUBDEV_PROP_BANDWIDTH:
+        uhd::warning::post(
+            str(boost::format("%s: No tunable bandwidth, fixed filtered to %0.2fMHz")
+                % get_rx_id().to_pp_string() % _max_freq
+            )
+        );
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
@@ -260,6 +283,10 @@ void basic_tx::tx_get(const wax::obj &key_, wax::obj &val){
         val = true; //there is no LO, so it must be true!
         return;
 
+    case SUBDEV_PROP_BANDWIDTH:
+        val = subdev_bandwidth_scalar[get_subdev_name()]*_max_freq;
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -284,6 +311,14 @@ void basic_tx::tx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_ENABLED:
         return; //always enabled
 
+    case SUBDEV_PROP_BANDWIDTH:
+        uhd::warning::post(
+            str(boost::format("%s: No tunable bandwidth, fixed filtered to %0.2fMHz")
+                % get_tx_id().to_pp_string() % _max_freq
+            )
+        );
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
diff --git a/host/lib/usrp/dboard/db_dbsrx.cpp b/host/lib/usrp/dboard/db_dbsrx.cpp
index 0b8b4db83..85251bdf9 100644
--- a/host/lib/usrp/dboard/db_dbsrx.cpp
+++ b/host/lib/usrp/dboard/db_dbsrx.cpp
@@ -175,7 +175,7 @@ UHD_STATIC_BLOCK(reg_dbsrx_dboard){
 dbsrx::dbsrx(ctor_args_t args) : rx_dboard_base(args){
     //warn user about incorrect DBID on USRP1, requires R193 populated
     if (this->get_iface()->get_special_props().soft_clock_divider and this->get_rx_id() == 0x000D)
-        uhd::print_warning(
+        uhd::warning::post(
             str(boost::format(
                 "DBSRX: incorrect dbid\n"
                 "Expected dbid 0x0002 and R193\n"
@@ -186,7 +186,7 @@ dbsrx::dbsrx(ctor_args_t args) : rx_dboard_base(args){
 
     //warn user about incorrect DBID on non-USRP1, requires R194 populated
     if (not this->get_iface()->get_special_props().soft_clock_divider and this->get_rx_id() == 0x0002)
-        uhd::print_warning(
+        uhd::warning::post(
             str(boost::format(
                 "DBSRX: incorrect dbid\n"
                 "Expected dbid 0x000D and R194\n"
@@ -236,8 +236,10 @@ void dbsrx::set_lo_freq(double target_freq){
     bool update_filter_settings = false;
     //choose refclock
     std::vector<double> clock_rates = this->get_iface()->get_clock_rates(dboard_iface::UNIT_RX);
+    const double max_clock_rate = std::sorted(clock_rates).back();
     BOOST_FOREACH(ref_clock, std::reversed(std::sorted(clock_rates))){
         if (ref_clock > 27.0e6) continue;
+        if (size_t(max_clock_rate/ref_clock)%2 == 1) continue; //reject asymmetric clocks (odd divisors)
 
         //choose m_divider such that filter tuning constraint is met
         m = 31;
@@ -340,7 +342,7 @@ void dbsrx::set_lo_freq(double target_freq){
         //vtune is too low, try lower frequency vco
         if (_max2118_read_regs.adc == 0){
             if (_max2118_write_regs.osc_band == 0){
-                uhd::print_warning(
+                uhd::warning::post(
                     str(boost::format(
                         "DBSRX: Tuning exceeded vco range, _max2118_write_regs.osc_band == %d\n" 
                         ) % int(_max2118_write_regs.osc_band))
@@ -354,7 +356,7 @@ void dbsrx::set_lo_freq(double target_freq){
         //vtune is too high, try higher frequency vco
         if (_max2118_read_regs.adc == 7){
             if (_max2118_write_regs.osc_band == 7){
-                uhd::print_warning(
+                uhd::warning::post(
                     str(boost::format(
                         "DBSRX: Tuning exceeded vco range, _max2118_write_regs.osc_band == %d\n" 
                         ) % int(_max2118_write_regs.osc_band))
@@ -561,7 +563,7 @@ void dbsrx::rx_get(const wax::obj &key_, wax::obj &val){
         return;
 
     case SUBDEV_PROP_BANDWIDTH:
-        val = _bandwidth;
+        val = 2*_bandwidth; //_bandwidth is low-pass, we want complex double-sided
         return;
 
     default: UHD_THROW_PROP_GET_ERROR();
@@ -586,7 +588,7 @@ void dbsrx::rx_set(const wax::obj &key_, const wax::obj &val){
         return; //always enabled
 
     case SUBDEV_PROP_BANDWIDTH:
-        this->set_bandwidth(val.as<double>());
+        this->set_bandwidth(val.as<double>()/2.0); //complex double-sided, we want low-pass
         return;
 
     default: UHD_THROW_PROP_SET_ERROR();
diff --git a/host/lib/usrp/dboard/db_dbsrx2.cpp b/host/lib/usrp/dboard/db_dbsrx2.cpp
new file mode 100644
index 000000000..5a65e6123
--- /dev/null
+++ b/host/lib/usrp/dboard/db_dbsrx2.cpp
@@ -0,0 +1,439 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+// No RX IO Pins Used
+
+#include "max2112_regs.hpp"
+#include <uhd/utils/static.hpp>
+#include <uhd/utils/assert.hpp>
+#include <uhd/utils/algorithm.hpp>
+#include <uhd/types/ranges.hpp>
+#include <uhd/types/dict.hpp>
+#include <uhd/usrp/subdev_props.hpp>
+#include <uhd/usrp/dboard_base.hpp>
+#include <uhd/usrp/dboard_manager.hpp>
+#include <boost/assign/list_of.hpp>
+#include <boost/format.hpp>
+#include <boost/thread.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <utility>
+
+using namespace uhd;
+using namespace uhd::usrp;
+using namespace boost::assign;
+
+/***********************************************************************
+ * The DBSRX2 constants
+ **********************************************************************/
+static const bool dbsrx2_debug = false;
+
+static const freq_range_t dbsrx2_freq_range(0.8e9, 2.4e9);
+
+static const int dbsrx2_ref_divider = 4; // Hitachi HMC426 divider (U7)
+
+static const prop_names_t dbsrx2_antennas = list_of("J3");
+
+static const uhd::dict<std::string, gain_range_t> dbsrx2_gain_ranges = map_list_of
+    ("GC1", gain_range_t(0, 73, float(0.05)))
+    ("BBG", gain_range_t(0, 15, 1))
+;
+
+/***********************************************************************
+ * The DBSRX2 dboard class
+ **********************************************************************/
+class dbsrx2 : public rx_dboard_base{
+public:
+    dbsrx2(ctor_args_t args);
+    ~dbsrx2(void);
+
+    void rx_get(const wax::obj &key, wax::obj &val);
+    void rx_set(const wax::obj &key, const wax::obj &val);
+
+private:
+    double _lo_freq;
+    double _bandwidth;
+    uhd::dict<std::string, float> _gains;
+    max2112_write_regs_t _max2112_write_regs;
+    max2112_read_regs_t _max2112_read_regs;
+    boost::uint8_t _max2112_addr(){ //0x60 or 0x61 depending on which side
+        return (this->get_iface()->get_special_props().mangle_i2c_addrs)? 0x60 : 0x61;
+    }
+
+    void set_lo_freq(double target_freq);
+    void set_gain(float gain, const std::string &name);
+    void set_bandwidth(double bandwidth);
+
+    void send_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){
+        start_reg = boost::uint8_t(std::clip(int(start_reg), 0x0, 0xB));
+        stop_reg = boost::uint8_t(std::clip(int(stop_reg), 0x0, 0xB));
+
+        for(boost::uint8_t start_addr=start_reg; start_addr <= stop_reg; start_addr += sizeof(boost::uint32_t) - 1){
+            int num_bytes = int(stop_reg - start_addr + 1) > int(sizeof(boost::uint32_t)) - 1 ? sizeof(boost::uint32_t) - 1 : stop_reg - start_addr + 1;
+
+            //create buffer for register data (+1 for start address)
+            byte_vector_t regs_vector(num_bytes + 1);
+
+            //first byte is the address of first register
+            regs_vector[0] = start_addr;
+
+            //get the register data
+            for(int i=0; i<num_bytes; i++){
+                regs_vector[1+i] = _max2112_write_regs.get_reg(start_addr+i);
+                if(dbsrx2_debug) std::cerr << boost::format(
+                    "DBSRX2: send reg 0x%02x, value 0x%04x, start_addr = 0x%04x, num_bytes %d"
+                ) % int(start_addr+i) % int(regs_vector[1+i]) % int(start_addr) % num_bytes << std::endl;
+            }
+
+            //send the data
+            this->get_iface()->write_i2c(
+                _max2112_addr(), regs_vector
+            );
+        }
+    }
+
+    void read_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){
+        static const boost::uint8_t status_addr = 0xC;
+        start_reg = boost::uint8_t(std::clip(int(start_reg), 0x0, 0xD));
+        stop_reg = boost::uint8_t(std::clip(int(stop_reg), 0x0, 0xD));
+
+        for(boost::uint8_t start_addr=start_reg; start_addr <= stop_reg; start_addr += sizeof(boost::uint32_t)){
+            int num_bytes = int(stop_reg - start_addr + 1) > int(sizeof(boost::uint32_t)) ? sizeof(boost::uint32_t) : stop_reg - start_addr + 1;
+
+            //create address to start reading register data
+            byte_vector_t address_vector(1);
+            address_vector[0] = start_addr;
+
+            //send the address
+            this->get_iface()->write_i2c(
+                _max2112_addr(), address_vector
+            );
+
+            //create buffer for register data
+            byte_vector_t regs_vector(num_bytes);
+
+            //read from i2c
+            regs_vector = this->get_iface()->read_i2c(
+                _max2112_addr(), num_bytes
+            );
+
+            for(boost::uint8_t i=0; i < num_bytes; i++){
+                if (i + start_addr >= status_addr){
+                    _max2112_read_regs.set_reg(i + start_addr, regs_vector[i]);
+                    /*
+                    if(dbsrx2_debug) std::cerr << boost::format(
+                        "DBSRX2: set reg 0x%02x, value 0x%04x"
+                    ) % int(i + start_addr) % int(_max2112_read_regs.get_reg(i + start_addr)) << std::endl;
+                    */
+                }
+                if(dbsrx2_debug) std::cerr << boost::format(
+                    "DBSRX2: read reg 0x%02x, value 0x%04x, start_addr = 0x%04x, num_bytes %d"
+                ) % int(start_addr+i) % int(regs_vector[i]) % int(start_addr) % num_bytes << std::endl;
+            }
+        }
+    }
+
+    /*!
+     * Is the LO locked?
+     * \return true for locked
+     */
+    bool get_locked(void){
+        read_reg(0xC, 0xD);
+
+        //mask and return lock detect
+        bool locked = (_max2112_read_regs.ld & _max2112_read_regs.vasa & _max2112_read_regs.vase) != 0;
+
+        if(dbsrx2_debug) std::cerr << boost::format(
+            "DBSRX2 locked: %d"
+        ) % locked << std::endl;
+
+        return locked;
+    }
+
+};
+
+/***********************************************************************
+ * Register the DBSRX2 dboard
+ **********************************************************************/
+// FIXME 0x67 is the default i2c address on USRP2
+//       need to handle which side for USRP1 with different address
+static dboard_base::sptr make_dbsrx2(dboard_base::ctor_args_t args){
+    return dboard_base::sptr(new dbsrx2(args));
+}
+
+UHD_STATIC_BLOCK(reg_dbsrx2_dboard){
+    //register the factory function for the rx dbid
+    dboard_manager::register_dboard(0x0012, &make_dbsrx2, "DBSRX2");
+}
+
+/***********************************************************************
+ * Structors
+ **********************************************************************/
+dbsrx2::dbsrx2(ctor_args_t args) : rx_dboard_base(args){
+    //enable only the clocks we need
+    this->get_iface()->set_clock_enabled(dboard_iface::UNIT_RX, true);
+
+    //set the gpio directions and atr controls (identically)
+    this->get_iface()->set_pin_ctrl(dboard_iface::UNIT_RX, 0x0); // All unused in atr
+    this->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX, 0x0); // All Inputs
+
+    //send initial register settings
+    send_reg(0x0, 0xB);
+    //for (boost::uint8_t addr=0; addr<=12; addr++) this->send_reg(addr, addr);
+
+    //set defaults for LO, gains
+    set_lo_freq(dbsrx2_freq_range.min);
+    BOOST_FOREACH(const std::string &name, dbsrx2_gain_ranges.keys()){
+        set_gain(dbsrx2_gain_ranges[name].min, name);
+    }
+
+    set_bandwidth(40e6); // default bandwidth from datasheet
+    get_locked();
+
+    _max2112_write_regs.bbg = boost::math::iround(std::clip<float>(0, dbsrx2_gain_ranges["BBG"].min, dbsrx2_gain_ranges["BBG"].max));
+    send_reg(0x9, 0x9);
+}
+
+dbsrx2::~dbsrx2(void){
+}
+
+
+/***********************************************************************
+ * Tuning
+ **********************************************************************/
+void dbsrx2::set_lo_freq(double target_freq){
+    //target_freq = std::clip(target_freq, dbsrx2_freq_range.min, dbsrx2_freq_range.max);
+
+    //variables used in the calculation below
+    int scaler = target_freq > 1125e6 ? 2 : 4;
+    double ref_freq = this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX);
+    int R, intdiv, fracdiv, ext_div;
+    double N;
+
+    //compute tuning variables
+    ext_div = dbsrx2_ref_divider; // 12MHz < ref_freq/ext_divider < 30MHz
+
+    R = 1; //Divide by 1 is the only tested value
+
+    N = (target_freq*R*ext_div)/(ref_freq); //actual spec range is (19, 251)
+    intdiv = int(std::floor(N)); //  if (intdiv < 19  or intdiv > 251) continue;
+    fracdiv = boost::math::iround((N - intdiv)*double(1 << 20));
+
+    //calculate the actual freq from the values above
+    N = double(intdiv) + double(fracdiv)/double(1 << 20);
+    _lo_freq = (N*ref_freq)/(R*ext_div);
+
+    //load new counters into registers
+    _max2112_write_regs.set_n_divider(intdiv);
+    _max2112_write_regs.set_f_divider(fracdiv);
+    _max2112_write_regs.r_divider = R;
+    _max2112_write_regs.d24 = scaler == 4 ? max2112_write_regs_t::D24_DIV4 : max2112_write_regs_t::D24_DIV2;
+
+    //debug output of calculated variables
+    if (dbsrx2_debug) std::cerr
+        << boost::format("DBSRX2 tune:\n")
+        << boost::format("    R=%d, N=%f, scaler=%d, ext_div=%d\n") % R % N % scaler % ext_div
+        << boost::format("    int=%d, frac=%d, d24=%d\n") % intdiv % fracdiv % int(_max2112_write_regs.d24)
+        << boost::format("    Ref    Freq=%fMHz\n") % (ref_freq/1e6)
+        << boost::format("    Target Freq=%fMHz\n") % (target_freq/1e6)
+        << boost::format("    Actual Freq=%fMHz\n") % (_lo_freq/1e6)
+        << std::endl;
+
+    //send the registers
+    send_reg(0x0, 0x7);
+
+    //FIXME: probably unnecessary to call get_locked here
+    //get_locked();
+
+}
+
+/***********************************************************************
+ * Gain Handling
+ **********************************************************************/
+/*!
+ * Convert a requested gain for the BBG vga into the integer register value.
+ * The gain passed into the function will be set to the actual value.
+ * \param gain the requested gain in dB
+ * \return 4 bit the register value
+ */
+static int gain_to_bbg_vga_reg(float &gain){
+    int reg = boost::math::iround(std::clip<float>(gain, dbsrx2_gain_ranges["BBG"].min, dbsrx2_gain_ranges["BBG"].max));
+
+    gain = float(reg);
+
+    if (dbsrx2_debug) std::cerr 
+        << boost::format("DBSRX2 BBG Gain:\n")
+        << boost::format("    %f dB, bbg: %d") % gain % reg 
+        << std::endl;
+
+    return reg;
+}
+
+/*!
+ * Convert a requested gain for the GC1 rf vga into the dac_volts value.
+ * The gain passed into the function will be set to the actual value.
+ * \param gain the requested gain in dB
+ * \return dac voltage value
+ */
+static float gain_to_gc1_rfvga_dac(float &gain){
+    //clip the input
+    gain = std::clip<float>(gain, dbsrx2_gain_ranges["GC1"].min, dbsrx2_gain_ranges["GC1"].max);
+
+    //voltage level constants
+    static const float max_volts = float(0.5), min_volts = float(2.7);
+    static const float slope = (max_volts-min_volts)/dbsrx2_gain_ranges["GC1"].max;
+
+    //calculate the voltage for the aux dac
+    float dac_volts = gain*slope + min_volts;
+
+    if (dbsrx2_debug) std::cerr 
+        << boost::format("DBSRX2 GC1 Gain:\n")
+        << boost::format("    %f dB, dac_volts: %f V") % gain % dac_volts 
+        << std::endl;
+
+    //the actual gain setting
+    gain = (dac_volts - min_volts)/slope;
+
+    return dac_volts;
+}
+
+void dbsrx2::set_gain(float gain, const std::string &name){
+    assert_has(dbsrx2_gain_ranges.keys(), name, "dbsrx2 gain name");
+    if (name == "BBG"){
+        _max2112_write_regs.bbg = gain_to_bbg_vga_reg(gain);
+        send_reg(0x9, 0x9);
+    }
+    else if(name == "GC1"){
+        //write the new voltage to the aux dac
+        this->get_iface()->write_aux_dac(dboard_iface::UNIT_RX, dboard_iface::AUX_DAC_A, gain_to_gc1_rfvga_dac(gain));
+    }
+    else UHD_THROW_INVALID_CODE_PATH();
+    _gains[name] = gain;
+}
+
+/***********************************************************************
+ * Bandwidth Handling
+ **********************************************************************/
+void dbsrx2::set_bandwidth(double bandwidth){
+    //clip the input
+    bandwidth = std::clip<double>(bandwidth, 4e6, 40e6);
+
+    _max2112_write_regs.lp = int((bandwidth/1e6 - 4)/0.29 + 12);
+    _bandwidth = double(4 + (_max2112_write_regs.lp - 12) * 0.29)*1e6;
+
+    if (dbsrx2_debug) std::cerr 
+        << boost::format("DBSRX2 Bandwidth:\n")
+        << boost::format("    %f MHz, lp: %f V") % (_bandwidth/1e6) % int(_max2112_write_regs.lp)
+        << std::endl;
+
+    this->send_reg(0x8, 0x8);
+}
+
+/***********************************************************************
+ * RX Get and Set
+ **********************************************************************/
+void dbsrx2::rx_get(const wax::obj &key_, wax::obj &val){
+    named_prop_t key = named_prop_t::extract(key_);
+
+    //handle the get request conditioned on the key
+    switch(key.as<subdev_prop_t>()){
+    case SUBDEV_PROP_NAME:
+        val = get_rx_id().to_pp_string();
+        return;
+
+    case SUBDEV_PROP_OTHERS:
+        val = prop_names_t(); //empty
+        return;
+
+    case SUBDEV_PROP_GAIN:
+        assert_has(_gains.keys(), key.name, "dbsrx2 gain name");
+        val = _gains[key.name];
+        return;
+
+    case SUBDEV_PROP_GAIN_RANGE:
+        assert_has(dbsrx2_gain_ranges.keys(), key.name, "dbsrx2 gain name");
+        val = dbsrx2_gain_ranges[key.name];
+        return;
+
+    case SUBDEV_PROP_GAIN_NAMES:
+        val = prop_names_t(dbsrx2_gain_ranges.keys());
+        return;
+
+    case SUBDEV_PROP_FREQ:
+        val = _lo_freq;
+        return;
+
+    case SUBDEV_PROP_FREQ_RANGE:
+        val = dbsrx2_freq_range;
+        return;
+
+    case SUBDEV_PROP_ANTENNA:
+        val = std::string("J3");
+        return;
+
+    case SUBDEV_PROP_ANTENNA_NAMES:
+        val = dbsrx2_antennas;
+        return;
+
+    case SUBDEV_PROP_CONNECTION:
+        val = SUBDEV_CONN_COMPLEX_QI;
+        return;
+
+    case SUBDEV_PROP_ENABLED:
+        val = true; //always enabled
+        return;
+
+    case SUBDEV_PROP_USE_LO_OFFSET:
+        val = false;
+        return;
+
+    case SUBDEV_PROP_LO_LOCKED:
+        val = this->get_locked();
+        return;
+
+    case SUBDEV_PROP_BANDWIDTH:
+        val = _bandwidth;
+        return;
+
+    default: UHD_THROW_PROP_GET_ERROR();
+    }
+}
+
+void dbsrx2::rx_set(const wax::obj &key_, const wax::obj &val){
+    named_prop_t key = named_prop_t::extract(key_);
+
+    //handle the get request conditioned on the key
+    switch(key.as<subdev_prop_t>()){
+
+    case SUBDEV_PROP_FREQ:
+        this->set_lo_freq(val.as<double>());
+        return;
+
+    case SUBDEV_PROP_GAIN:
+        this->set_gain(val.as<float>(), key.name);
+        return;
+
+    case SUBDEV_PROP_ENABLED:
+        return; //always enabled
+
+    case SUBDEV_PROP_BANDWIDTH:
+        this->set_bandwidth(val.as<double>());
+        return;
+
+    default: UHD_THROW_PROP_SET_ERROR();
+    }
+}
+
diff --git a/host/lib/usrp/dboard/db_rfx.cpp b/host/lib/usrp/dboard/db_rfx.cpp
index 3c24d90db..152198c3a 100644
--- a/host/lib/usrp/dboard/db_rfx.cpp
+++ b/host/lib/usrp/dboard/db_rfx.cpp
@@ -43,6 +43,7 @@
 #include <uhd/utils/assert.hpp>
 #include <uhd/utils/static.hpp>
 #include <uhd/utils/algorithm.hpp>
+#include <uhd/utils/warning.hpp>
 #include <uhd/usrp/dboard_id.hpp>
 #include <uhd/usrp/dboard_base.hpp>
 #include <uhd/usrp/dboard_manager.hpp>
@@ -456,6 +457,10 @@ void rfx_xcvr::rx_get(const wax::obj &key_, wax::obj &val){
         val = this->get_locked(dboard_iface::UNIT_RX);
         return;
 
+    case SUBDEV_PROP_BANDWIDTH:
+        val = 2*20.0e6; //20MHz low-pass, we want complex double-sided
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -481,6 +486,12 @@ void rfx_xcvr::rx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_ENABLED:
         return; //always enabled
 
+    case SUBDEV_PROP_BANDWIDTH:
+        uhd::warning::post(
+            str(boost::format("RFX: No tunable bandwidth, fixed filtered to 40MHz"))
+        );
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
@@ -543,6 +554,10 @@ void rfx_xcvr::tx_get(const wax::obj &key_, wax::obj &val){
         val = this->get_locked(dboard_iface::UNIT_TX);
         return;
 
+    case SUBDEV_PROP_BANDWIDTH:
+        val = 2*20.0e6; //20MHz low-pass, we want complex double-sided
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -568,6 +583,12 @@ void rfx_xcvr::tx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_ENABLED:
         return; //always enabled
 
+    case SUBDEV_PROP_BANDWIDTH:
+        uhd::warning::post(
+            str(boost::format("RFX: No tunable bandwidth, fixed filtered to 40MHz"))
+        );
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
diff --git a/host/lib/usrp/dboard/db_tvrx.cpp b/host/lib/usrp/dboard/db_tvrx.cpp
index d39dc3bf8..2873e3d54 100644
--- a/host/lib/usrp/dboard/db_tvrx.cpp
+++ b/host/lib/usrp/dboard/db_tvrx.cpp
@@ -459,6 +459,10 @@ void tvrx::rx_get(const wax::obj &key_, wax::obj &val){
         val = true;
         return;
 
+    case SUBDEV_PROP_BANDWIDTH:
+        val = 6.0e6;
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -479,6 +483,12 @@ void tvrx::rx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_ENABLED:
         return; //always enabled
 
+    case SUBDEV_PROP_BANDWIDTH:
+        uhd::warning::post(
+            str(boost::format("TVRX: No tunable bandwidth, fixed filtered to 6MHz"))
+        );
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
diff --git a/host/lib/usrp/dboard/db_unknown.cpp b/host/lib/usrp/dboard/db_unknown.cpp
index ec7ab440b..d0359d124 100644
--- a/host/lib/usrp/dboard/db_unknown.cpp
+++ b/host/lib/usrp/dboard/db_unknown.cpp
@@ -19,23 +19,52 @@
 #include <uhd/types/ranges.hpp>
 #include <uhd/utils/assert.hpp>
 #include <uhd/utils/static.hpp>
+#include <uhd/utils/warning.hpp>
 #include <uhd/usrp/dboard_base.hpp>
 #include <uhd/usrp/dboard_manager.hpp>
 #include <boost/assign/list_of.hpp>
 #include <boost/format.hpp>
+#include <boost/foreach.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <vector>
 
 using namespace uhd;
 using namespace uhd::usrp;
 using namespace boost::assign;
 
 /***********************************************************************
+ * Utility functions
+ **********************************************************************/
+static void warn_if_old_rfx(const dboard_id_t &dboard_id, const std::string &xx){
+    typedef boost::tuple<std::string, dboard_id_t, dboard_id_t> old_ids_t; //name, rx_id, tx_id
+    static const std::vector<old_ids_t> old_rfx_ids = list_of
+        (old_ids_t("Flex 400 Classic",  0x0004, 0x0008))
+        (old_ids_t("Flex 900 Classic",  0x0005, 0x0009))
+        (old_ids_t("Flex 1200 Classic", 0x0006, 0x000a))
+        (old_ids_t("Flex 1800 Classic", 0x0030, 0x0031))
+        (old_ids_t("Flex 2400 Classic", 0x0007, 0x000b))
+    ;
+    BOOST_FOREACH(const old_ids_t &old_id, old_rfx_ids){
+        std::string name; dboard_id_t rx_id, tx_id;
+        boost::tie(name, rx_id, tx_id) = old_id;
+        if (
+            (xx == "RX" and rx_id == dboard_id) or
+            (xx == "TX" and tx_id == dboard_id)
+        ) uhd::warning::post(str(boost::format(
+            "Detected %s daughterboard %s\n"
+            "This board requires modification to use.\n"
+            "See the daughterboard application notes.\n"
+        ) % xx % name));
+    }
+}
+
+/***********************************************************************
  * The unknown boards:
  *   Like a basic board, but with only one subdev.
  **********************************************************************/
 class unknown_rx : public rx_dboard_base{
 public:
     unknown_rx(ctor_args_t args);
-    ~unknown_rx(void);
 
     void rx_get(const wax::obj &key, wax::obj &val);
     void rx_set(const wax::obj &key, const wax::obj &val);
@@ -44,7 +73,6 @@ public:
 class unknown_tx : public tx_dboard_base{
 public:
     unknown_tx(ctor_args_t args);
-    ~unknown_tx(void);
 
     void tx_get(const wax::obj &key, wax::obj &val);
     void tx_set(const wax::obj &key, const wax::obj &val);
@@ -70,11 +98,7 @@ UHD_STATIC_BLOCK(reg_unknown_dboards){
  * Unknown RX dboard
  **********************************************************************/
 unknown_rx::unknown_rx(ctor_args_t args) : rx_dboard_base(args){
-    /* NOP */
-}
-
-unknown_rx::~unknown_rx(void){
-    /* NOP */
+    warn_if_old_rfx(this->get_rx_id(), "RX");
 }
 
 void unknown_rx::rx_get(const wax::obj &key_, wax::obj &val){
@@ -134,6 +158,10 @@ void unknown_rx::rx_get(const wax::obj &key_, wax::obj &val){
         val = true; //there is no LO, so it must be true!
         return;
 
+    case SUBDEV_PROP_BANDWIDTH:
+        val = 0.0;
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -158,19 +186,21 @@ void unknown_rx::rx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_ENABLED:
         return; //always enabled
 
+    case SUBDEV_PROP_BANDWIDTH:
+        uhd::warning::post(
+            str(boost::format("Unknown Daughterboard: No tunable bandwidth, fixed filtered to 0.0MHz"))
+        );
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
 
 /***********************************************************************
- * Basic and LF TX dboard
+ * Unknown TX dboard
  **********************************************************************/
 unknown_tx::unknown_tx(ctor_args_t args) : tx_dboard_base(args){
-    /* NOP */
-}
-
-unknown_tx::~unknown_tx(void){
-    /* NOP */
+    warn_if_old_rfx(this->get_tx_id(), "TX");
 }
 
 void unknown_tx::tx_get(const wax::obj &key_, wax::obj &val){
@@ -230,6 +260,10 @@ void unknown_tx::tx_get(const wax::obj &key_, wax::obj &val){
         val = true; //there is no LO, so it must be true!
         return;
 
+    case SUBDEV_PROP_BANDWIDTH:
+        val = 0.0;
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -254,6 +288,12 @@ void unknown_tx::tx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_ENABLED:
         return; //always enabled
 
+    case SUBDEV_PROP_BANDWIDTH:
+        uhd::warning::post(
+            str(boost::format("Unknown Daughterboard: No tunable bandwidth, fixed filtered to 0.0MHz"))
+        );
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
diff --git a/host/lib/usrp/dboard/db_wbx.cpp b/host/lib/usrp/dboard/db_wbx.cpp
index 907268aac..572f5de97 100644
--- a/host/lib/usrp/dboard/db_wbx.cpp
+++ b/host/lib/usrp/dboard/db_wbx.cpp
@@ -71,6 +71,7 @@
 #include <uhd/utils/assert.hpp>
 #include <uhd/utils/static.hpp>
 #include <uhd/utils/algorithm.hpp>
+#include <uhd/utils/warning.hpp>
 #include <uhd/usrp/dboard_base.hpp>
 #include <uhd/usrp/dboard_manager.hpp>
 #include <boost/assign/list_of.hpp>
@@ -525,6 +526,10 @@ void wbx_xcvr::rx_get(const wax::obj &key_, wax::obj &val){
         val = this->get_locked(dboard_iface::UNIT_RX);
         return;
 
+    case SUBDEV_PROP_BANDWIDTH:
+        val = 2*20.0e6; //20MHz low-pass, we want complex double-sided
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -550,6 +555,12 @@ void wbx_xcvr::rx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_ENABLED:
         return; //always enabled
 
+    case SUBDEV_PROP_BANDWIDTH:
+        uhd::warning::post(
+            str(boost::format("WBX: No tunable bandwidth, fixed filtered to 40MHz"))
+        );
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
@@ -616,6 +627,10 @@ void wbx_xcvr::tx_get(const wax::obj &key_, wax::obj &val){
         val = this->get_locked(dboard_iface::UNIT_TX);
         return;
 
+    case SUBDEV_PROP_BANDWIDTH:
+        val = 2*20.0e6; //20MHz low-pass, we want complex double-sided
+        return;
+
     default: UHD_THROW_PROP_GET_ERROR();
     }
 }
@@ -641,6 +656,12 @@ void wbx_xcvr::tx_set(const wax::obj &key_, const wax::obj &val){
     case SUBDEV_PROP_ENABLED:
         return; //always enabled
 
+    case SUBDEV_PROP_BANDWIDTH:
+        uhd::warning::post(
+            str(boost::format("WBX: No tunable bandwidth, fixed filtered to 40MHz"))
+        );
+        return;
+
     default: UHD_THROW_PROP_SET_ERROR();
     }
 }
diff --git a/host/lib/usrp/dboard/db_xcvr2450.cpp b/host/lib/usrp/dboard/db_xcvr2450.cpp
index fb1367113..be0e42b92 100644
--- a/host/lib/usrp/dboard/db_xcvr2450.cpp
+++ b/host/lib/usrp/dboard/db_xcvr2450.cpp
@@ -626,7 +626,7 @@ void xcvr2450::rx_get(const wax::obj &key_, wax::obj &val){
         return;
 
     case SUBDEV_PROP_BANDWIDTH:
-        val = _rx_bandwidth;
+        val = 2*_rx_bandwidth; //_tx_bandwidth is low-pass, we want complex double-sided
         return;
 
     default: UHD_THROW_PROP_GET_ERROR();
@@ -652,7 +652,7 @@ void xcvr2450::rx_set(const wax::obj &key_, const wax::obj &val){
         return;
 
     case SUBDEV_PROP_BANDWIDTH:
-        this->set_rx_bandwidth(val.as<double>());
+        this->set_rx_bandwidth(val.as<double>()/2.0); //complex double-sided, we want low-pass
         return;
 
     case SUBDEV_PROP_ENABLED:
@@ -725,7 +725,7 @@ void xcvr2450::tx_get(const wax::obj &key_, wax::obj &val){
         return;
 
     case SUBDEV_PROP_BANDWIDTH:
-        val = _tx_bandwidth;
+        val = 2*_tx_bandwidth; //_tx_bandwidth is low-pass, we want complex double-sided
         return;
 
     default: UHD_THROW_PROP_GET_ERROR();
@@ -747,7 +747,7 @@ void xcvr2450::tx_set(const wax::obj &key_, const wax::obj &val){
         return;
 
     case SUBDEV_PROP_BANDWIDTH:
-        this->set_tx_bandwidth(val.as<double>());
+        this->set_tx_bandwidth(val.as<double>()/2.0); //complex double-sided, we want low-pass
         return;
 
     case SUBDEV_PROP_ANTENNA: