Merge branch 'master' into next

26 files changed, 144 insertions, 80 deletions

diff --git a/host/cmake/Modules/UHDVersion.cmake b/host/cmake/Modules/UHDVersion.cmake
index b9ddddae3..13d952353 100644
--- a/host/cmake/Modules/UHDVersion.cmake
+++ b/host/cmake/Modules/UHDVersion.cmake
@@ -27,7 +27,7 @@ FIND_PACKAGE(Git QUIET)
 ########################################################################
 SET(UHD_VERSION_MAJOR 003)
 SET(UHD_VERSION_MINOR 004)
-SET(UHD_VERSION_PATCH 000)
+SET(UHD_VERSION_PATCH 001)
 
 ########################################################################
 # Version information discovery through git log
@@ -68,4 +68,8 @@ IF(UHD_RELEASE_MODE)
 ENDIF()
 
 ########################################################################
-SET(UHD_VERSION "${UHD_VERSION_MAJOR}.${UHD_VERSION_MINOR}.${UHD_VERSION_PATCH}-${UHD_GIT_COUNT}-${UHD_GIT_HASH}")
+IF(UHD_RELEASE_MODE STREQUAL "release")
+    SET(UHD_VERSION "${UHD_VERSION_MAJOR}.${UHD_VERSION_MINOR}.${UHD_VERSION_PATCH}-${UHD_GIT_HASH}")
+ELSE()
+    SET(UHD_VERSION "${UHD_VERSION_MAJOR}.${UHD_VERSION_MINOR}.${UHD_VERSION_PATCH}-${UHD_GIT_COUNT}-${UHD_GIT_HASH}")
+ENDIF()
diff --git a/host/examples/benchmark_rate.cpp b/host/examples/benchmark_rate.cpp
index 8f00e25de..8a000f6c3 100644
--- a/host/examples/benchmark_rate.cpp
+++ b/host/examples/benchmark_rate.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2011 Ettus Research LLC
+// Copyright 2011-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
@@ -16,6 +16,7 @@
 //
 
 #include <uhd/utils/thread_priority.hpp>
+#include <uhd/convert.hpp>
 #include <uhd/utils/safe_main.hpp>
 #include <uhd/usrp/multi_usrp.hpp>
 #include <boost/program_options.hpp>
@@ -40,11 +41,13 @@ unsigned long long num_seq_errors = 0;
 /***********************************************************************
  * Benchmark RX Rate
  **********************************************************************/
-void benchmark_rx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_otw){
+void benchmark_rx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_cpu, const std::string &rx_otw){
     uhd::set_thread_priority_safe();
 
     //create a receive streamer
-    uhd::stream_args_t stream_args("fc32", rx_otw); //complex floats
+    uhd::stream_args_t stream_args(rx_cpu, rx_otw);
+    for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
+        stream_args.channels.push_back(ch);
     uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
 
     //print pre-test summary
@@ -55,16 +58,20 @@ void benchmark_rx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_o
     //setup variables and allocate buffer
     uhd::rx_metadata_t md;
     const size_t max_samps_per_packet = rx_stream->get_max_num_samps();
-    std::vector<std::complex<float> > buff(max_samps_per_packet);
+    std::vector<char> buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(rx_cpu));
+    std::vector<void *> buffs;
+    for (size_t ch = 0; ch < stream_args.channels.size(); ch++)
+        buffs.push_back(&buff.front()); //same buffer for each channel
     bool had_an_overflow = false;
     uhd::time_spec_t last_time;
     const double rate = usrp->get_rx_rate();
 
-    usrp->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
+    uhd::stream_cmd_t cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
+    cmd.time_spec = usrp->get_time_now() + uhd::time_spec_t(0.05);
+    cmd.stream_now = (buffs.size() == 1);
+    usrp->issue_stream_cmd(cmd);
     while (not boost::this_thread::interruption_requested()){
-        num_rx_samps += rx_stream->recv(
-            &buff.front(), buff.size(), md
-        );
+        num_rx_samps += rx_stream->recv(buffs, max_samps_per_packet, md);
 
         //handle the error codes
         switch(md.error_code){
@@ -94,11 +101,13 @@ void benchmark_rx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_o
 /***********************************************************************
  * Benchmark TX Rate
  **********************************************************************/
-void benchmark_tx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_otw){
+void benchmark_tx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_cpu, const std::string &tx_otw){
     uhd::set_thread_priority_safe();
 
     //create a transmit streamer
-    uhd::stream_args_t stream_args("fc32", tx_otw); //complex floats
+    uhd::stream_args_t stream_args(tx_cpu, tx_otw);
+    for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
+        stream_args.channels.push_back(ch);
     uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
 
     //print pre-test summary
@@ -108,17 +117,22 @@ void benchmark_tx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_o
 
     //setup variables and allocate buffer
     uhd::tx_metadata_t md;
-    md.has_time_spec = false;
+    md.time_spec = usrp->get_time_now() + uhd::time_spec_t(0.05);
     const size_t max_samps_per_packet = tx_stream->get_max_num_samps();
-    std::vector<std::complex<float> > buff(max_samps_per_packet);
+    std::vector<char> buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(tx_cpu));
+    std::vector<const void *> buffs;
+    for (size_t ch = 0; ch < stream_args.channels.size(); ch++)
+        buffs.push_back(&buff.front()); //same buffer for each channel
+    md.has_time_spec = (buffs.size() != 1);
 
     while (not boost::this_thread::interruption_requested()){
-        num_tx_samps += tx_stream->send(&buff.front(), buff.size(), md);
+        num_tx_samps += tx_stream->send(buffs, max_samps_per_packet, md);
+        md.has_time_spec = false;
     }
 
     //send a mini EOB packet
     md.end_of_burst = true;
-    tx_stream->send("", 0, md);
+    tx_stream->send(buffs, 0, md);
 }
 
 void benchmark_tx_rate_async_helper(uhd::usrp::multi_usrp::sptr usrp){
@@ -163,6 +177,8 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
     double duration;
     double rx_rate, tx_rate;
     std::string rx_otw, tx_otw;
+    std::string rx_cpu, tx_cpu;
+    std::string mode;
 
     //setup the program options
     po::options_description desc("Allowed options");
@@ -174,6 +190,9 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
         ("tx_rate", po::value<double>(&tx_rate), "specify to perform a TX rate test (sps)")
         ("rx_otw", po::value<std::string>(&rx_otw)->default_value("sc16"), "specify the over-the-wire sample mode for RX")
         ("tx_otw", po::value<std::string>(&tx_otw)->default_value("sc16"), "specify the over-the-wire sample mode for TX")
+        ("rx_cpu", po::value<std::string>(&rx_cpu)->default_value("fc32"), "specify the host/cpu sample mode for RX")
+        ("tx_cpu", po::value<std::string>(&tx_cpu)->default_value("fc32"), "specify the host/cpu sample mode for TX")
+        ("mode", po::value<std::string>(&mode)->default_value("none"), "multi-channel sync mode option: none, mimo")
     ;
     po::variables_map vm;
     po::store(po::parse_command_line(argc, argv, desc), vm);
@@ -201,18 +220,24 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
     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;
 
+    if (mode == "mimo"){
+        usrp->set_clock_source("mimo", 0);
+        usrp->set_time_source("mimo", 0);
+        boost::this_thread::sleep(boost::posix_time::seconds(1));
+    }
+
     boost::thread_group thread_group;
 
     //spawn the receive test thread
     if (vm.count("rx_rate")){
         usrp->set_rx_rate(rx_rate);
-        thread_group.create_thread(boost::bind(&benchmark_rx_rate, usrp, rx_otw));
+        thread_group.create_thread(boost::bind(&benchmark_rx_rate, usrp, rx_cpu, rx_otw));
     }
 
     //spawn the transmit test thread
     if (vm.count("tx_rate")){
         usrp->set_tx_rate(tx_rate);
-        thread_group.create_thread(boost::bind(&benchmark_tx_rate, usrp, tx_otw));
+        thread_group.create_thread(boost::bind(&benchmark_tx_rate, usrp, tx_cpu, tx_otw));
         thread_group.create_thread(boost::bind(&benchmark_tx_rate_async_helper, usrp));
     }
 
diff --git a/host/include/uhd/usrp/dboard_iface.hpp b/host/include/uhd/usrp/dboard_iface.hpp
index ca5de5c2f..6a6a68321 100644
--- a/host/include/uhd/usrp/dboard_iface.hpp
+++ b/host/include/uhd/usrp/dboard_iface.hpp
@@ -213,7 +213,7 @@ public:
      *
      * \param unit which unit, rx or tx
      * \param config configuration settings
-     * \param data the bits to write LSB first
+     * \param data the bits to write MSB first
      * \param num_bits the number of bits in data
      */
     virtual void write_spi(
@@ -228,7 +228,7 @@ public:
      *
      * \param unit which unit, rx or tx
      * \param config configuration settings
-     * \param data the bits to write LSB first
+     * \param data the bits to write MSB first
      * \param num_bits the number of bits in data
      * \return the data that was read
      */
diff --git a/host/lib/convert/convert_common.hpp b/host/lib/convert/convert_common.hpp
index 55bc2e99d..29ea94870 100644
--- a/host/lib/convert/convert_common.hpp
+++ b/host/lib/convert/convert_common.hpp
@@ -57,8 +57,8 @@ static const int PRIORITY_SIMD = 1; //neon conversions could be implemented bett
 static const int PRIORITY_TABLE = 2; //tables require large cache, so they are slower on arm
 #else
 static const int PRIORITY_LIBORC = 1;
-static const int PRIORITY_SIMD = 2;
-static const int PRIORITY_TABLE = 3;
+static const int PRIORITY_SIMD = 3;
+static const int PRIORITY_TABLE = 2;
 #endif
 
 /***********************************************************************
diff --git a/host/lib/transport/super_recv_packet_handler.hpp b/host/lib/transport/super_recv_packet_handler.hpp
index 74fbe82fb..205c7a3a3 100644
--- a/host/lib/transport/super_recv_packet_handler.hpp
+++ b/host/lib/transport/super_recv_packet_handler.hpp
@@ -306,7 +306,7 @@ private:
         #endif
 
         //3) check for out of order timestamps
-        if (info.ifpi.has_tsi and info.ifpi.has_tsf and prev_buffer_info[index].time > info.time){
+        if (info.ifpi.has_tsf and prev_buffer_info[index].time > info.time){
             return PACKET_TIMESTAMP_ERROR;
         }
 
diff --git a/host/lib/transport/super_send_packet_handler.hpp b/host/lib/transport/super_send_packet_handler.hpp
index 46c98afea..8a4fce11e 100644
--- a/host/lib/transport/super_send_packet_handler.hpp
+++ b/host/lib/transport/super_send_packet_handler.hpp
@@ -242,6 +242,7 @@ private:
             //commit the samples to the zero-copy interface
             size_t num_bytes_total = (_header_offset_words32+if_packet_info.num_packet_words32)*sizeof(boost::uint32_t);
             buff->commit(num_bytes_total);
+            buff.reset(); //effectively a release
 
         }
         _next_packet_seq++; //increment sequence after commits
diff --git a/host/lib/transport/usb_zero_copy_wrapper.cpp b/host/lib/transport/usb_zero_copy_wrapper.cpp
index 690e5aaa2..3571ed856 100644
--- a/host/lib/transport/usb_zero_copy_wrapper.cpp
+++ b/host/lib/transport/usb_zero_copy_wrapper.cpp
@@ -35,10 +35,9 @@ public:
         _queue(queue){/*NOP*/}
 
     void release(void){
-        if (_mrb.get() == NULL) return;
-        _mrb->release();
+        if (not _mrb) return;
+        _mrb.reset(); //decrement ref count, other MRB's may hold a ref
         _queue.push_with_haste(this);
-        _mrb.reset();
     }
 
     UHD_INLINE sptr get_new(managed_recv_buffer::sptr mrb, const void *mem, size_t len){
diff --git a/host/lib/usrp/b100/b100_impl.cpp b/host/lib/usrp/b100/b100_impl.cpp
index 991e6efd3..38bd89fea 100644
--- a/host/lib/usrp/b100/b100_impl.cpp
+++ b/host/lib/usrp/b100/b100_impl.cpp
@@ -260,7 +260,8 @@ b100_impl::b100_impl(const device_addr_t &device_addr){
     ////////////////////////////////////////////////////////////////////
     _tree->create<std::string>("/name").set("B-Series Device");
     const fs_path mb_path = "/mboards/0";
-    _tree->create<std::string>(mb_path / "name").set("B100 (B-Hundo)");
+    _tree->create<std::string>(mb_path / "name").set("B100");
+    _tree->create<std::string>(mb_path / "codename").set("B-Hundo");
     _tree->create<std::string>(mb_path / "load_eeprom")
         .subscribe(boost::bind(&fx2_ctrl::usrp_load_eeprom, _fx2_ctrl, _1));
 
diff --git a/host/lib/usrp/dboard/db_basic_and_lf.cpp b/host/lib/usrp/dboard/db_basic_and_lf.cpp
index fc42a73d5..2b30dab52 100644
--- a/host/lib/usrp/dboard/db_basic_and_lf.cpp
+++ b/host/lib/usrp/dboard/db_basic_and_lf.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010-2011 Ettus Research LLC
+// 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
@@ -108,11 +108,17 @@ basic_rx::basic_rx(ctor_args_t args, double max_freq) : rx_dboard_base(args){
     ////////////////////////////////////////////////////////////////////
     // Register properties
     ////////////////////////////////////////////////////////////////////
-    this->get_rx_subtree()->create<std::string>("name").set(
-        std::string(str(boost::format("%s - %s")
-            % get_rx_id().to_pp_string()
-            % get_subdev_name()
+    if(get_rx_id() == 0x0001){
+        this->get_rx_subtree()->create<std::string>("name").set(
+            std::string(str(boost::format("BasicRX (%s)") % get_subdev_name()
         )));
+    }
+    else{
+        this->get_rx_subtree()->create<std::string>("name").set(
+            std::string(str(boost::format("LFRX (%s)") % get_subdev_name()
+        )));
+    }
+
     this->get_rx_subtree()->create<int>("gains"); //phony property so this dir exists
     this->get_rx_subtree()->create<double>("freq/value")
         .publish(&always_zero_freq);
@@ -157,11 +163,17 @@ basic_tx::basic_tx(ctor_args_t args, double max_freq) : tx_dboard_base(args){
     ////////////////////////////////////////////////////////////////////
     // Register properties
     ////////////////////////////////////////////////////////////////////
-    this->get_tx_subtree()->create<std::string>("name").set(
-        std::string(str(boost::format("%s - %s")
-            % get_tx_id().to_pp_string()
-            % get_subdev_name()
+    if(get_tx_id() == 0x0000){
+        this->get_tx_subtree()->create<std::string>("name").set(
+            std::string(str(boost::format("BasicTX (%s)") % get_subdev_name()
         )));
+    }
+    else{
+        this->get_tx_subtree()->create<std::string>("name").set(
+            std::string(str(boost::format("LFTX (%s)") % get_subdev_name()
+        )));
+    }
+
     this->get_tx_subtree()->create<int>("gains"); //phony property so this dir exists
     this->get_tx_subtree()->create<double>("freq/value")
         .publish(&always_zero_freq);
diff --git a/host/lib/usrp/dboard/db_dbsrx.cpp b/host/lib/usrp/dboard/db_dbsrx.cpp
index 95c5c5d4d..b1cee4aa7 100644
--- a/host/lib/usrp/dboard/db_dbsrx.cpp
+++ b/host/lib/usrp/dboard/db_dbsrx.cpp
@@ -202,7 +202,7 @@ dbsrx::dbsrx(ctor_args_t args) : rx_dboard_base(args){
     // Register properties
     ////////////////////////////////////////////////////////////////////
     this->get_rx_subtree()->create<std::string>("name")
-        .set(get_rx_id().to_pp_string());
+        .set("DBSRX");
     this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
         .publish(boost::bind(&dbsrx::get_locked, this));
     BOOST_FOREACH(const std::string &name, dbsrx_gain_ranges.keys()){
diff --git a/host/lib/usrp/dboard/db_dbsrx2.cpp b/host/lib/usrp/dboard/db_dbsrx2.cpp
index 517b7b183..013f3178a 100644
--- a/host/lib/usrp/dboard/db_dbsrx2.cpp
+++ b/host/lib/usrp/dboard/db_dbsrx2.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010-2011 Ettus Research LLC
+// 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
@@ -189,7 +189,7 @@ dbsrx2::dbsrx2(ctor_args_t args) : rx_dboard_base(args){
     // Register properties
     ////////////////////////////////////////////////////////////////////
     this->get_rx_subtree()->create<std::string>("name")
-        .set(get_rx_id().to_pp_string());
+        .set("DBSRX2");
     this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
         .publish(boost::bind(&dbsrx2::get_locked, this));
     BOOST_FOREACH(const std::string &name, dbsrx2_gain_ranges.keys()){
diff --git a/host/lib/usrp/dboard/db_rfx.cpp b/host/lib/usrp/dboard/db_rfx.cpp
index 6e32b5fe5..d934be294 100644
--- a/host/lib/usrp/dboard/db_rfx.cpp
+++ b/host/lib/usrp/dboard/db_rfx.cpp
@@ -174,7 +174,14 @@ rfx_xcvr::rfx_xcvr(
     ////////////////////////////////////////////////////////////////////
     // Register RX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_rx_subtree()->create<std::string>("name").set("RFX RX");
+    if(get_rx_id() == 0x0024) this->get_rx_subtree()->create<std::string>("name").set("RFX400 RX");
+    else if(get_rx_id() == 0x0025) this->get_rx_subtree()->create<std::string>("name").set("RFX900 RX");
+    else if(get_rx_id() == 0x0034) this->get_rx_subtree()->create<std::string>("name").set("RFX1800 RX");
+    else if(get_rx_id() == 0x0026) this->get_rx_subtree()->create<std::string>("name").set("RFX1200 RX");
+    else if(get_rx_id() == 0x002c) this->get_rx_subtree()->create<std::string>("name").set("RFX2200 RX");
+    else if(get_rx_id() == 0x0027) this->get_rx_subtree()->create<std::string>("name").set("RFX2400 RX");
+    else this->get_rx_subtree()->create<std::string>("name").set("RFX RX");
+
     this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
         .publish(boost::bind(&rfx_xcvr::get_locked, this, dboard_iface::UNIT_RX));
     BOOST_FOREACH(const std::string &name, _rx_gain_ranges.keys()){
@@ -203,7 +210,14 @@ rfx_xcvr::rfx_xcvr(
     ////////////////////////////////////////////////////////////////////
     // Register TX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_tx_subtree()->create<std::string>("name").set("RFX TX");
+    if(get_tx_id() == 0x0028) this->get_tx_subtree()->create<std::string>("name").set("RFX400 TX");
+    else if(get_tx_id() == 0x0029) this->get_tx_subtree()->create<std::string>("name").set("RFX900 TX");
+    else if(get_tx_id() == 0x0035) this->get_tx_subtree()->create<std::string>("name").set("RFX1800 TX");
+    else if(get_tx_id() == 0x002a) this->get_tx_subtree()->create<std::string>("name").set("RFX1200 TX");
+    else if(get_tx_id() == 0x002d) this->get_tx_subtree()->create<std::string>("name").set("RFX2200 TX");
+    else if(get_tx_id() == 0x002b) this->get_tx_subtree()->create<std::string>("name").set("RFX2400 TX");
+    else this->get_tx_subtree()->create<std::string>("name").set("RFX TX");
+
     this->get_tx_subtree()->create<sensor_value_t>("sensors/lo_locked")
         .publish(boost::bind(&rfx_xcvr::get_locked, this, dboard_iface::UNIT_TX));
     this->get_tx_subtree()->create<int>("gains"); //phony property so this dir exists
diff --git a/host/lib/usrp/dboard/db_sbx_common.cpp b/host/lib/usrp/dboard/db_sbx_common.cpp
index 3cfc1e95f..a51dee361 100644
--- a/host/lib/usrp/dboard/db_sbx_common.cpp
+++ b/host/lib/usrp/dboard/db_sbx_common.cpp
@@ -127,7 +127,10 @@ sbx_xcvr::sbx_xcvr(ctor_args_t args) : xcvr_dboard_base(args){
     ////////////////////////////////////////////////////////////////////
     // Register RX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_rx_subtree()->create<std::string>("name").set("SBX RX");
+    if(get_rx_id() == 0x054) this->get_rx_subtree()->create<std::string>("name").set("SBXv3 RX");
+    else if(get_rx_id() == 0x065) this->get_rx_subtree()->create<std::string>("name").set("SBXv4 RX");
+    else this->get_rx_subtree()->create<std::string>("name").set("SBX RX");
+
     this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
         .publish(boost::bind(&sbx_xcvr::get_locked, this, dboard_iface::UNIT_RX));
     BOOST_FOREACH(const std::string &name, sbx_rx_gain_ranges.keys()){
@@ -156,7 +159,10 @@ sbx_xcvr::sbx_xcvr(ctor_args_t args) : xcvr_dboard_base(args){
     ////////////////////////////////////////////////////////////////////
     // Register TX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_tx_subtree()->create<std::string>("name").set("SBX TX");
+    if(get_tx_id() == 0x055) this->get_tx_subtree()->create<std::string>("name").set("SBXv3 TX");
+    else if(get_tx_id() == 0x067) this->get_tx_subtree()->create<std::string>("name").set("SBXv4 TX");
+    else this->get_tx_subtree()->create<std::string>("name").set("SBX TX");
+
     this->get_tx_subtree()->create<sensor_value_t>("sensors/lo_locked")
         .publish(boost::bind(&sbx_xcvr::get_locked, this, dboard_iface::UNIT_TX));
     BOOST_FOREACH(const std::string &name, sbx_tx_gain_ranges.keys()){
diff --git a/host/lib/usrp/dboard/db_tvrx.cpp b/host/lib/usrp/dboard/db_tvrx.cpp
index fd86d5b83..edee46cd5 100644
--- a/host/lib/usrp/dboard/db_tvrx.cpp
+++ b/host/lib/usrp/dboard/db_tvrx.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010-2011 Ettus Research LLC
+// 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
@@ -186,7 +186,7 @@ tvrx::tvrx(ctor_args_t args) : rx_dboard_base(args){
     // Register properties
     ////////////////////////////////////////////////////////////////////
     this->get_rx_subtree()->create<std::string>("name")
-        .set(get_rx_id().to_pp_string());
+        .set("TVRX");
     this->get_rx_subtree()->create<int>("sensors"); //phony property so this dir exists
     BOOST_FOREACH(const std::string &name, get_tvrx_gain_ranges().keys()){
         this->get_rx_subtree()->create<double>("gains/"+name+"/value")
diff --git a/host/lib/usrp/dboard/db_tvrx2.cpp b/host/lib/usrp/dboard/db_tvrx2.cpp
index 628221527..0bfa5229a 100644
--- a/host/lib/usrp/dboard/db_tvrx2.cpp
+++ b/host/lib/usrp/dboard/db_tvrx2.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010 Ettus Research LLC
+// 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
@@ -955,7 +955,7 @@ tvrx2::tvrx2(ctor_args_t args) : rx_dboard_base(args){
     // Register properties
     ////////////////////////////////////////////////////////////////////
     this->get_rx_subtree()->create<std::string>("name")
-        .set(get_rx_id().to_pp_string());
+        .set("TVRX2");
     this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
         .publish(boost::bind(&tvrx2::get_locked, this));
     this->get_rx_subtree()->create<sensor_value_t>("sensors/rssi")
diff --git a/host/lib/usrp/dboard/db_wbx_simple.cpp b/host/lib/usrp/dboard/db_wbx_simple.cpp
index 3d633a672..4ba30255d 100644
--- a/host/lib/usrp/dboard/db_wbx_simple.cpp
+++ b/host/lib/usrp/dboard/db_wbx_simple.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2011 Ettus Research LLC
+// Copyright 2011-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
@@ -81,8 +81,10 @@ wbx_simple::wbx_simple(ctor_args_t args) : wbx_base(args){
     ////////////////////////////////////////////////////////////////////
     // Register RX properties
     ////////////////////////////////////////////////////////////////////
+
     this->get_rx_subtree()->access<std::string>("name").set(
-        this->get_rx_subtree()->access<std::string>("name").get() + " + Simple GDB");
+        std::string(str(boost::format("%s+GDB") % this->get_rx_subtree()->access<std::string>("name").get()
+    )));
     this->get_rx_subtree()->create<std::string>("antenna/value")
         .subscribe(boost::bind(&wbx_simple::set_rx_ant, this, _1))
         .set("RX2");
@@ -93,7 +95,8 @@ wbx_simple::wbx_simple(ctor_args_t args) : wbx_base(args){
     // Register TX properties
     ////////////////////////////////////////////////////////////////////
     this->get_tx_subtree()->access<std::string>("name").set(
-        this->get_tx_subtree()->access<std::string>("name").get() + " + Simple GDB");
+        std::string(str(boost::format("%s+GDB") % this->get_tx_subtree()->access<std::string>("name").get()
+    )));
     this->get_tx_subtree()->create<std::string>("antenna/value")
         .subscribe(boost::bind(&wbx_simple::set_tx_ant, this, _1))
         .set(wbx_tx_antennas.at(0));
diff --git a/host/lib/usrp/dboard/db_wbx_version2.cpp b/host/lib/usrp/dboard/db_wbx_version2.cpp
index ef91a7553..0c0a63fda 100644
--- a/host/lib/usrp/dboard/db_wbx_version2.cpp
+++ b/host/lib/usrp/dboard/db_wbx_version2.cpp
@@ -78,7 +78,7 @@ wbx_base::wbx_version2::wbx_version2(wbx_base *_self_wbx_base) {
     ////////////////////////////////////////////////////////////////////
     // Register RX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_rx_subtree()->create<std::string>("name").set("WBX RX v2");
+    this->get_rx_subtree()->create<std::string>("name").set("WBXv2 RX");
     this->get_rx_subtree()->create<double>("freq/value")
          .coerce(boost::bind(&wbx_base::wbx_version2::set_lo_freq, this, dboard_iface::UNIT_RX, _1))
          .set((wbx_v2_freq_range.start() + wbx_v2_freq_range.stop())/2.0);
@@ -87,7 +87,7 @@ wbx_base::wbx_version2::wbx_version2(wbx_base *_self_wbx_base) {
     ////////////////////////////////////////////////////////////////////
     // Register TX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_tx_subtree()->create<std::string>("name").set("WBX TX v2");
+    this->get_tx_subtree()->create<std::string>("name").set("WBXv2 TX");
     BOOST_FOREACH(const std::string &name, wbx_v2_tx_gain_ranges.keys()){
         self_base->get_tx_subtree()->create<double>("gains/"+name+"/value")
             .coerce(boost::bind(&wbx_base::wbx_version2::set_tx_gain, this, _1, name))
diff --git a/host/lib/usrp/dboard/db_wbx_version3.cpp b/host/lib/usrp/dboard/db_wbx_version3.cpp
index 95b48d182..1f67b37c9 100644
--- a/host/lib/usrp/dboard/db_wbx_version3.cpp
+++ b/host/lib/usrp/dboard/db_wbx_version3.cpp
@@ -84,7 +84,7 @@ wbx_base::wbx_version3::wbx_version3(wbx_base *_self_wbx_base) {
     ////////////////////////////////////////////////////////////////////
     // Register RX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_rx_subtree()->create<std::string>("name").set("WBX RX v3");
+    this->get_rx_subtree()->create<std::string>("name").set("WBXv3 RX");
     this->get_rx_subtree()->create<double>("freq/value")
          .coerce(boost::bind(&wbx_base::wbx_version3::set_lo_freq, this, dboard_iface::UNIT_RX, _1))
          .set((wbx_v3_freq_range.start() + wbx_v3_freq_range.stop())/2.0);
@@ -93,7 +93,7 @@ wbx_base::wbx_version3::wbx_version3(wbx_base *_self_wbx_base) {
     ////////////////////////////////////////////////////////////////////
     // Register TX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_tx_subtree()->create<std::string>("name").set("WBX TX v3");
+    this->get_tx_subtree()->create<std::string>("name").set("WBXv3 TX");
     BOOST_FOREACH(const std::string &name, wbx_v3_tx_gain_ranges.keys()){
         self_base->get_tx_subtree()->create<double>("gains/"+name+"/value")
             .coerce(boost::bind(&wbx_base::wbx_version3::set_tx_gain, this, _1, name))
diff --git a/host/lib/usrp/dboard/db_wbx_version4.cpp b/host/lib/usrp/dboard/db_wbx_version4.cpp
index 384e5790d..dd6c3c9ef 100644
--- a/host/lib/usrp/dboard/db_wbx_version4.cpp
+++ b/host/lib/usrp/dboard/db_wbx_version4.cpp
@@ -85,7 +85,7 @@ wbx_base::wbx_version4::wbx_version4(wbx_base *_self_wbx_base) {
     ////////////////////////////////////////////////////////////////////
     // Register RX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_rx_subtree()->create<std::string>("name").set("WBX RX v4");
+    this->get_rx_subtree()->create<std::string>("name").set("WBXv4 RX");
     this->get_rx_subtree()->create<double>("freq/value")
          .coerce(boost::bind(&wbx_base::wbx_version4::set_lo_freq, this, dboard_iface::UNIT_RX, _1))
          .set((wbx_v4_freq_range.start() + wbx_v4_freq_range.stop())/2.0);
@@ -94,7 +94,7 @@ wbx_base::wbx_version4::wbx_version4(wbx_base *_self_wbx_base) {
     ////////////////////////////////////////////////////////////////////
     // Register TX properties
     ////////////////////////////////////////////////////////////////////
-    this->get_tx_subtree()->create<std::string>("name").set("WBX TX v4");
+    this->get_tx_subtree()->create<std::string>("name").set("WBXv4 TX");
     BOOST_FOREACH(const std::string &name, wbx_v4_tx_gain_ranges.keys()){
         self_base->get_tx_subtree()->create<double>("gains/"+name+"/value")
             .coerce(boost::bind(&wbx_base::wbx_version4::set_tx_gain, this, _1, name))
diff --git a/host/lib/usrp/dboard/db_xcvr2450.cpp b/host/lib/usrp/dboard/db_xcvr2450.cpp
index 0fdad0d40..6685b806d 100644
--- a/host/lib/usrp/dboard/db_xcvr2450.cpp
+++ b/host/lib/usrp/dboard/db_xcvr2450.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010-2011 Ettus Research LLC
+// 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
@@ -228,7 +228,7 @@ xcvr2450::xcvr2450(ctor_args_t args) : xcvr_dboard_base(args){
     // Register RX properties
     ////////////////////////////////////////////////////////////////////
     this->get_rx_subtree()->create<std::string>("name")
-        .set(get_rx_id().to_pp_string());
+        .set("XCVR2450 RX");
     this->get_rx_subtree()->create<sensor_value_t>("sensors/lo_locked")
         .publish(boost::bind(&xcvr2450::get_locked, this));
     this->get_rx_subtree()->create<sensor_value_t>("sensors/rssi")
@@ -266,7 +266,7 @@ xcvr2450::xcvr2450(ctor_args_t args) : xcvr_dboard_base(args){
     // Register TX properties
     ////////////////////////////////////////////////////////////////////
     this->get_tx_subtree()->create<std::string>("name")
-        .set(get_tx_id().to_pp_string());
+        .set("XCVR2450 TX");
     this->get_tx_subtree()->create<sensor_value_t>("sensors/lo_locked")
         .publish(boost::bind(&xcvr2450::get_locked, this));
     BOOST_FOREACH(const std::string &name, xcvr_tx_gain_ranges.keys()){
diff --git a/host/lib/usrp/e100/e100_impl.cpp b/host/lib/usrp/e100/e100_impl.cpp
index d610c0b12..ec459b2c4 100644
--- a/host/lib/usrp/e100/e100_impl.cpp
+++ b/host/lib/usrp/e100/e100_impl.cpp
@@ -189,7 +189,8 @@ e100_impl::e100_impl(const uhd::device_addr_t &device_addr){
     ////////////////////////////////////////////////////////////////////
     _tree->create<std::string>("/name").set("E-Series Device");
     const fs_path mb_path = "/mboards/0";
-    _tree->create<std::string>(mb_path / "name").set(str(boost::format("%s (euewanee)") % model));
+    _tree->create<std::string>(mb_path / "name").set(model);
+    _tree->create<std::string>(mb_path / "codename").set("Euwanee");
 
     ////////////////////////////////////////////////////////////////////
     // setup the mboard eeprom
diff --git a/host/lib/usrp/multi_usrp.cpp b/host/lib/usrp/multi_usrp.cpp
index 43dd3bf14..fe3c923d3 100644
--- a/host/lib/usrp/multi_usrp.cpp
+++ b/host/lib/usrp/multi_usrp.cpp
@@ -242,11 +242,7 @@ public:
         dict<std::string, std::string> usrp_info;
 
         mboard_eeprom_t mb_eeprom = _tree->access<mboard_eeprom_t>(mb_root(mcp.mboard) / "eeprom").get();
-        dboard_eeprom_t gdb_eeprom = _tree->access<dboard_eeprom_t>(tx_rf_fe_root(mcp.chan).branch_path().branch_path() / "gdb_eeprom").get();
-        dboard_eeprom_t db_eeprom;
-
-        if(gdb_eeprom.id != dboard_id_t::none()) db_eeprom = gdb_eeprom;
-        else db_eeprom = _tree->access<dboard_eeprom_t>(tx_rf_fe_root(mcp.chan).branch_path().branch_path() / "tx_eeprom").get();
+        dboard_eeprom_t db_eeprom = _tree->access<dboard_eeprom_t>(tx_rf_fe_root(mcp.chan).branch_path().branch_path() / "tx_eeprom").get();
 
         usrp_info["mboard_id"] = _tree->access<std::string>(mb_root(mcp.mboard) / "name").get();
         usrp_info["mboard_name"] = mb_eeprom["name"];
diff --git a/host/lib/usrp/usrp1/usrp1_impl.cpp b/host/lib/usrp/usrp1/usrp1_impl.cpp
index 1db2efa0d..33b40dd2f 100644
--- a/host/lib/usrp/usrp1/usrp1_impl.cpp
+++ b/host/lib/usrp/usrp1/usrp1_impl.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010-2011 Ettus Research LLC
+// 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
@@ -214,7 +214,7 @@ usrp1_impl::usrp1_impl(const device_addr_t &device_addr){
     _tree = property_tree::make();
     _tree->create<std::string>("/name").set("USRP1 Device");
     const fs_path mb_path = "/mboards/0";
-    _tree->create<std::string>(mb_path / "name").set("USRP1 (Classic)");
+    _tree->create<std::string>(mb_path / "name").set("USRP1");
     _tree->create<std::string>(mb_path / "load_eeprom")
         .subscribe(boost::bind(&fx2_ctrl::usrp_load_eeprom, _fx2_ctrl, _1));
 
diff --git a/host/lib/usrp/usrp2/usrp2_iface.cpp b/host/lib/usrp/usrp2/usrp2_iface.cpp
index 123910166..b202b6170 100644
--- a/host/lib/usrp/usrp2/usrp2_iface.cpp
+++ b/host/lib/usrp/usrp2/usrp2_iface.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010-2011 Ettus Research LLC
+// 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
@@ -340,13 +340,13 @@ public:
 
     const std::string get_cname(void){
         switch(this->get_rev()){
-        case USRP2_REV3: return "USRP2-REV3";
-        case USRP2_REV4: return "USRP2-REV4";
-        case USRP_N200: return "USRP-N200";
-        case USRP_N210: return "USRP-N210";
-        case USRP_N200_R4: return "USRP-N200-REV4";
-        case USRP_N210_R4: return "USRP-N210-REV4";
-        case USRP_NXXX: return "USRP-N???";
+        case USRP2_REV3: return "USRP2 r3";
+        case USRP2_REV4: return "USRP2 r4";
+        case USRP_N200: return "N200";
+        case USRP_N210: return "N210";
+        case USRP_N200_R4: return "N200r4";
+        case USRP_N210_R4: return "N210r4";
+        case USRP_NXXX: return "N???";
         }
         UHD_THROW_INVALID_CODE_PATH();
     }
diff --git a/host/utils/usrp2_card_burner.py b/host/utils/usrp2_card_burner.py
index 34c40d5a0..02d5c4b18 100755
--- a/host/utils/usrp2_card_burner.py
+++ b/host/utils/usrp2_card_burner.py
@@ -50,7 +50,7 @@ def command(*args):
         stderr=subprocess.STDOUT,
     )
     ret = p.wait()
-    verbose = p.stdout.read().decode()
+    verbose = p.stdout.read().decode('utf-8', errors='ignore')
     if ret != 0: raise Exception(verbose)
     return verbose
 
diff --git a/host/utils/usrp_n2xx_net_burner.py b/host/utils/usrp_n2xx_net_burner.py
index 31c94405b..6d1c02712 100755
--- a/host/utils/usrp_n2xx_net_burner.py
+++ b/host/utils/usrp_n2xx_net_burner.py
@@ -134,7 +134,7 @@ def command(*args):
         stderr=subprocess.STDOUT,
     )
     ret = p.wait()
-    verbose = p.stdout.read().decode()
+    verbose = p.stdout.read().decode('utf-8', errors='ignore')
     if ret != 0: raise Exception(verbose)
     return verbose
 
@@ -196,8 +196,10 @@ def win_get_interfaces():
             adNode = a.ipAddressList
             while True:
                 #convert ipAddr and ipMask into hex addrs that can be turned into a bcast addr
-                ipAddr = adNode.ipAddress.decode()
-                ipMask = adNode.ipMask.decode()
+                try:
+                    ipAddr = adNode.ipAddress.decode()
+                    ipMask = adNode.ipMask.decode()
+                except AttributeError: pass
                 if ipAddr and ipMask:
                     hexAddr = struct.unpack("<L", socket.inet_aton(ipAddr))[0]
                     hexMask = struct.unpack("<L", socket.inet_aton(ipMask))[0]
@@ -282,7 +284,7 @@ class burner_socket(object):
         (flash_size, sector_size) = self.get_flash_info()
         hw_rev = self.get_hw_rev()
 
-        if n2xx_revs.has_key(hw_rev): print("Hardware type: %s" % n2xx_revs[hw_rev][0])
+        if hw_rev in n2xx_revs: print("Hardware type: %s" % n2xx_revs[hw_rev][0])
         print("Flash size: %i\nSector size: %i\n" % (flash_size, sector_size))
 
         if fpga: