Merge branch 'calibration'

30 files changed, 1576 insertions, 43 deletions

diff --git a/host/docs/CMakeLists.txt b/host/docs/CMakeLists.txt
index fe3799a2f..e393a79f0 100644
--- a/host/docs/CMakeLists.txt
+++ b/host/docs/CMakeLists.txt
@@ -22,6 +22,7 @@ SET(manual_sources
     index.rst
     identification.rst
     build.rst
+    calibration.rst
     coding.rst
     dboards.rst
     gpsdo.rst
diff --git a/host/docs/calibration.rst b/host/docs/calibration.rst
new file mode 100644
index 000000000..0aaace8f4
--- /dev/null
+++ b/host/docs/calibration.rst
@@ -0,0 +1,56 @@
+========================================================================
+UHD - Calibration Application Notes
+========================================================================
+
+.. contents:: Table of Contents
+
+------------------------------------------------------------------------
+Self-calibration
+------------------------------------------------------------------------
+The UHD comes with several self-calibration utilities for minimizing IQ imbalance and DC offset.
+These utilities perform calibration sweeps using transmit leakage into the receive path
+(special equipment is not required).
+The results from a calibration are written to a csv file in the user's home directory.
+UHD will automatically apply corrections at runtime when the user changes settings.
+Calibration results are specific to an individual RF board.
+
+UHD comes with the following calibration utilities:
+
+ * **uhd_cal_rx_iq_balance:** - mimimizes RX IQ imbalance vs LO frequency
+ * **uhd_cal_tx_dc_offset:** - mimimizes TX DC offset vs LO frequency
+ * **uhd_cal_tx_iq_balance:** - mimimizes TX IQ imbalance vs LO frequency
+
+
+The following RF frontends are supported by the self-calibration utilities:
+
+ * WBX transceiver board
+ * SBX transceiver board
+ * more to come...
+
+********************************************
+Calibration utilities
+********************************************
+UHD installs the calibration utilities into <install-path>/bin.
+**Disconnect** any extrernal hardware from the RF antenna ports,
+and run the following from the command line.
+Each utility will take several minutes to complete.
+::
+
+    uhd_cal_rx_iq_balance --verbose --args=<optional device args>
+    uhd_cal_tx_iq_balance --verbose --args=<optional device args>
+    uhd_cal_tx_dc_offset --verbose --args=<optional device args>
+
+See the output given by --help for more advanced options, such as:
+manually choosing the frequency range and step size for the sweeps.
+
+********************************************
+Calibration data
+********************************************
+Calibration files are stored in the user's home/application directory.
+They can easily be moved from machine to another by copying the "cal" directory.
+Re-running a calibration utility will replace the existing calibration file.
+The old calibration file will be renamed so it may be recovered by the user.
+
+ * **Unix:** ${HOME}/.uhd/cal/
+ * **Windows:** %APPDATA%\\.uhd\\cal\\
+
diff --git a/host/docs/index.rst b/host/docs/index.rst
index 0b24927e9..f881e8585 100644
--- a/host/docs/index.rst
+++ b/host/docs/index.rst
@@ -30,6 +30,7 @@ Application Notes
 * `Transport Application Notes <./transport.html>`_
 * `Synchronization Application Notes <./sync.html>`_
 * `Internal GPSDO Application Notes <./gpsdo.html>`_
+* `Calibration Application Notes <./calibration.html>`_
 
 ^^^^^^^^^^^^^^^^^^^^^
 API Documentation
diff --git a/host/include/uhd/utils/CMakeLists.txt b/host/include/uhd/utils/CMakeLists.txt
index 48b8db885..5a434fd9a 100644
--- a/host/include/uhd/utils/CMakeLists.txt
+++ b/host/include/uhd/utils/CMakeLists.txt
@@ -21,10 +21,12 @@ INSTALL(FILES
     assert_has.ipp
     byteswap.hpp
     byteswap.ipp
+    csv.hpp
     gain_group.hpp
     images.hpp
     log.hpp
     msg.hpp
+    paths.hpp
     pimpl.hpp
     safe_call.hpp
     safe_main.hpp
diff --git a/host/include/uhd/utils/csv.hpp b/host/include/uhd/utils/csv.hpp
new file mode 100644
index 000000000..8dbb28377
--- /dev/null
+++ b/host/include/uhd/utils/csv.hpp
@@ -0,0 +1,35 @@
+//
+// Copyright 2011 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_CSV_HPP
+#define INCLUDED_UHD_UTILS_CSV_HPP
+
+#include <uhd/config.hpp>
+#include <vector>
+#include <string>
+#include <istream>
+
+namespace uhd{ namespace csv{
+    typedef std::vector<std::string> row_type;
+    typedef std::vector<row_type> rows_type;
+
+    //! Convert an input stream to csv rows.
+    UHD_API rows_type to_rows(std::istream &input);
+
+}} //namespace uhd::csv
+
+#endif /* INCLUDED_UHD_UTILS_CSV_HPP */
diff --git a/host/include/uhd/utils/paths.hpp b/host/include/uhd/utils/paths.hpp
new file mode 100644
index 000000000..2261f1b77
--- /dev/null
+++ b/host/include/uhd/utils/paths.hpp
@@ -0,0 +1,34 @@
+//
+// Copyright 2011 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_PATHS_HPP
+#define INCLUDED_UHD_UTILS_PATHS_HPP
+
+#include <uhd/config.hpp>
+#include <string>
+
+namespace uhd{
+
+    //! Get a string representing the system's temporary directory
+    UHD_API std::string get_tmp_path(void);
+
+    //! Get a string representing the system's appdata directory
+    UHD_API std::string get_app_path(void);
+
+} //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 c506559be..7674a0fcf 100644
--- a/host/lib/usrp/b100/b100_impl.cpp
+++ b/host/lib/usrp/b100/b100_impl.cpp
@@ -15,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
+#include "apply_corrections.hpp"
 #include "b100_impl.hpp"
 #include "b100_ctrl.hpp"
 #include "fpga_regs_standard.h"
@@ -293,13 +294,13 @@ b100_impl::b100_impl(const device_addr_t &device_addr){
         .set(true);
     _tree->create<std::complex<double> >(rx_fe_path / "iq_balance" / "value")
         .subscribe(boost::bind(&rx_frontend_core_200::set_iq_balance, _rx_fe, _1))
-        .set(std::complex<double>(0.0, 0.0));
+        .set(std::polar<double>(1.0, 0.0));
     _tree->create<std::complex<double> >(tx_fe_path / "dc_offset" / "value")
         .coerce(boost::bind(&tx_frontend_core_200::set_dc_offset, _tx_fe, _1))
         .set(std::complex<double>(0.0, 0.0));
     _tree->create<std::complex<double> >(tx_fe_path / "iq_balance" / "value")
         .subscribe(boost::bind(&tx_frontend_core_200::set_iq_balance, _tx_fe, _1))
-        .set(std::complex<double>(0.0, 0.0));
+        .set(std::polar<double>(1.0, 0.0));
 
     ////////////////////////////////////////////////////////////////////
     // create rx dsp control objects
@@ -408,6 +409,18 @@ b100_impl::b100_impl(const device_addr_t &device_addr){
         _dboard_iface, _tree->subtree(mb_path / "dboards/A")
     );
 
+    //bind frontend corrections to the dboard freq props
+    const fs_path db_tx_fe_path = mb_path / "dboards" / "A" / "tx_frontends";
+    BOOST_FOREACH(const std::string &name, _tree->list(db_tx_fe_path)){
+        _tree->access<double>(db_tx_fe_path / name / "freq" / "value")
+            .subscribe(boost::bind(&b100_impl::set_tx_fe_corrections, this, _1));
+    }
+    const fs_path db_rx_fe_path = mb_path / "dboards" / "A" / "rx_frontends";
+    BOOST_FOREACH(const std::string &name, _tree->list(db_rx_fe_path)){
+        _tree->access<double>(db_rx_fe_path / name / "freq" / "value")
+            .subscribe(boost::bind(&b100_impl::set_rx_fe_corrections, this, _1));
+    }
+
     //initialize io handling
     this->io_init();
 
@@ -501,3 +514,11 @@ sensor_value_t b100_impl::get_ref_locked(void){
     const bool lock = _clock_ctrl->get_locked();
     return sensor_value_t("Ref", lock, "locked", "unlocked");
 }
+
+void b100_impl::set_rx_fe_corrections(const double lo_freq){
+    apply_rx_fe_corrections(this->get_tree()->subtree("/mboards/0"), "A", lo_freq);
+}
+
+void b100_impl::set_tx_fe_corrections(const double lo_freq){
+    apply_tx_fe_corrections(this->get_tree()->subtree("/mboards/0"), "A", lo_freq);
+}
diff --git a/host/lib/usrp/b100/b100_impl.hpp b/host/lib/usrp/b100/b100_impl.hpp
index 0984260be..96d90b14c 100644
--- a/host/lib/usrp/b100/b100_impl.hpp
+++ b/host/lib/usrp/b100/b100_impl.hpp
@@ -125,6 +125,8 @@ private:
     void clear_fpga_fifo(void);
     void handle_async_message(uhd::transport::managed_recv_buffer::sptr);
     uhd::sensor_value_t get_ref_locked(void);
+    void set_rx_fe_corrections(const double);
+    void set_tx_fe_corrections(const double);
 };
 
 #endif /* INCLUDED_b100_IMPL_HPP */
diff --git a/host/lib/usrp/common/CMakeLists.txt b/host/lib/usrp/common/CMakeLists.txt
index ec8b60fec..9abd34afa 100644
--- a/host/lib/usrp/common/CMakeLists.txt
+++ b/host/lib/usrp/common/CMakeLists.txt
@@ -29,6 +29,7 @@ ENDIF(ENABLE_USB)
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 LIBUHD_APPEND_SOURCES(
+    ${CMAKE_CURRENT_SOURCE_DIR}/apply_corrections.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/validate_subdev_spec.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/recv_packet_demuxer.cpp
 )
diff --git a/host/lib/usrp/common/apply_corrections.cpp b/host/lib/usrp/common/apply_corrections.cpp
new file mode 100644
index 000000000..6aee00753
--- /dev/null
+++ b/host/lib/usrp/common/apply_corrections.cpp
@@ -0,0 +1,217 @@
+//
+// Copyright 2011 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 "apply_corrections.hpp"
+#include <uhd/usrp/dboard_eeprom.hpp>
+#include <uhd/utils/paths.hpp>
+#include <uhd/utils/msg.hpp>
+#include <uhd/utils/csv.hpp>
+#include <uhd/types/dict.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/foreach.hpp>
+#include <boost/thread/mutex.hpp>
+#include <cstdio>
+#include <complex>
+#include <fstream>
+
+namespace fs = boost::filesystem;
+
+boost::mutex corrections_mutex;
+
+/***********************************************************************
+ * Helper routines
+ **********************************************************************/
+static double linear_interp(double x, double x0, double y0, double x1, double y1){
+    return y0 + (x - x0)*(y1 - y0)/(x1 - x0);
+}
+
+/***********************************************************************
+ * FE apply corrections implementation
+ **********************************************************************/
+struct fe_cal_t{
+    double lo_freq;
+    double iq_corr_real;
+    double iq_corr_imag;
+};
+
+static bool fe_cal_comp(fe_cal_t a, fe_cal_t b){
+    return (a.lo_freq < b.lo_freq);
+}
+
+static uhd::dict<std::string, std::vector<fe_cal_t> > fe_cal_cache;
+
+static std::complex<double> get_fe_dc_correction(
+    const std::string &key, const double lo_freq
+){
+    const std::vector<fe_cal_t> &datas = fe_cal_cache[key];
+    if (datas.empty()) throw uhd::runtime_error("empty calibration table " + key);
+
+    //search for lo freq
+    size_t lo_index = 0;
+    size_t hi_index = datas.size()-1;
+    for (size_t i = 0; i < datas.size(); i++){
+        if (datas[i].lo_freq > lo_freq){
+            hi_index = i;
+            break;
+        }
+        lo_index = i;
+    }
+
+    if (lo_index == 0) return std::complex<double>(datas[lo_index].iq_corr_real, datas[lo_index].iq_corr_imag);
+    if (hi_index == lo_index) return std::complex<double>(datas[hi_index].iq_corr_real, datas[hi_index].iq_corr_imag);
+
+    //interpolation time
+    return std::complex<double>(
+        linear_interp(lo_freq, datas[lo_index].lo_freq, datas[lo_index].iq_corr_real, datas[hi_index].lo_freq, datas[hi_index].iq_corr_real),
+        linear_interp(lo_freq, datas[lo_index].lo_freq, datas[lo_index].iq_corr_imag, datas[hi_index].lo_freq, datas[hi_index].iq_corr_imag)
+    );
+}
+
+static std::complex<double> get_fe_iq_correction(
+    const std::string &key, const double lo_freq
+){
+    const std::vector<fe_cal_t> &datas = fe_cal_cache[key];
+    if (datas.empty()) throw uhd::runtime_error("empty calibration table " + key);
+
+    //search for lo freq
+    size_t lo_index = 0;
+    size_t hi_index = datas.size()-1;
+    for (size_t i = 0; i < datas.size(); i++){
+        if (datas[i].lo_freq > lo_freq){
+            hi_index = i;
+            break;
+        }
+        lo_index = i;
+    }
+
+    if (lo_index == 0) return std::complex<double>(datas[lo_index].iq_corr_real, datas[lo_index].iq_corr_imag);
+    if (hi_index == lo_index) return std::complex<double>(datas[hi_index].iq_corr_real, datas[hi_index].iq_corr_imag);
+
+    const std::complex<double> lo_val(datas[lo_index].iq_corr_real, datas[lo_index].iq_corr_imag);
+    const std::complex<double> hi_val(datas[hi_index].iq_corr_real, datas[hi_index].iq_corr_imag);
+
+    //interpolation time
+    return std::polar<double>(
+        linear_interp(lo_freq, datas[lo_index].lo_freq, std::abs(lo_val), datas[hi_index].lo_freq, std::abs(hi_val)),
+        linear_interp(lo_freq, datas[lo_index].lo_freq, std::arg(lo_val), datas[hi_index].lo_freq, std::arg(hi_val))
+    );
+}
+
+static void apply_fe_corrections(
+    uhd::property_tree::sptr sub_tree,
+    const uhd::fs_path &db_path,
+    const uhd::fs_path &fe_path,
+    const std::string &file_prefix,
+    const double lo_freq
+){
+    //extract eeprom serial
+    const uhd::usrp::dboard_eeprom_t db_eeprom = sub_tree->access<uhd::usrp::dboard_eeprom_t>(db_path).get();
+
+    //make the calibration file path
+    const fs::path cal_data_path = fs::path(uhd::get_app_path()) / ".uhd" / "cal" / (file_prefix + db_eeprom.serial + ".csv");
+    if (not fs::exists(cal_data_path)) return;
+
+    //parse csv file or get from cache
+    if (not fe_cal_cache.has_key(cal_data_path.string())){
+        std::ifstream cal_data(cal_data_path.string().c_str());
+        const uhd::csv::rows_type rows = uhd::csv::to_rows(cal_data);
+
+        bool read_data = false, skip_next = false;;
+        std::vector<fe_cal_t> datas;
+        BOOST_FOREACH(const uhd::csv::row_type &row, rows){
+            if (not read_data and not row.empty() and row[0] == "DATA STARTS HERE"){
+                read_data = true;
+                skip_next = true;
+                continue;
+            }
+            if (not read_data) continue;
+            if (skip_next){
+                skip_next = false;
+                continue;
+            }
+            fe_cal_t data;
+            std::sscanf(row[0].c_str(), "%lf" , &data.lo_freq);
+            std::sscanf(row[1].c_str(), "%lf" , &data.iq_corr_real);
+            std::sscanf(row[2].c_str(), "%lf" , &data.iq_corr_imag);
+            datas.push_back(data);
+        }
+        std::sort(datas.begin(), datas.end(), fe_cal_comp);
+        fe_cal_cache[cal_data_path.string()] = datas;
+        UHD_MSG(status) << "Loaded " << cal_data_path.string() << std::endl;
+
+    }
+
+    if (file_prefix.find("dc_cal") != std::string::npos){
+        sub_tree->access<std::complex<double> >(fe_path)
+            .set(get_fe_dc_correction(cal_data_path.string(), lo_freq));
+    }
+    else if (file_prefix.find("iq_cal") != std::string::npos){
+        sub_tree->access<std::complex<double> >(fe_path)
+            .set(get_fe_iq_correction(cal_data_path.string(), lo_freq));
+    }
+    else throw uhd::runtime_error("could not determine interpolation function");
+}
+
+/***********************************************************************
+ * Wrapper routines with nice try/catch + print
+ **********************************************************************/
+void uhd::usrp::apply_tx_fe_corrections(
+    property_tree::sptr sub_tree, //starts at mboards/x
+    const std::string &slot, //name of dboard slot
+    const double lo_freq //actual lo freq
+){
+    boost::mutex::scoped_lock l(corrections_mutex);
+    try{
+        apply_fe_corrections(
+            sub_tree,
+            "dboards/" + slot + "/tx_eeprom",
+            "tx_frontends/" + slot + "/iq_balance/value",
+            "tx_iq_cal_v0.1_",
+            lo_freq
+        );
+        apply_fe_corrections(
+            sub_tree,
+            "dboards/" + slot + "/tx_eeprom",
+            "tx_frontends/" + slot + "/dc_offset/value",
+            "tx_dc_cal_v0.1_",
+            lo_freq
+        );
+    }
+    catch(const std::exception &e){
+        UHD_MSG(error) << "Failure in apply_tx_fe_corrections: " << e.what() << std::endl;
+    }
+}
+
+void uhd::usrp::apply_rx_fe_corrections(
+    property_tree::sptr sub_tree, //starts at mboards/x
+    const std::string &slot, //name of dboard slot
+    const double lo_freq //actual lo freq
+){
+    boost::mutex::scoped_lock l(corrections_mutex);
+    try{
+        apply_fe_corrections(
+            sub_tree,
+            "dboards/" + slot + "/rx_eeprom",
+            "rx_frontends/" + slot + "/iq_balance/value",
+            "rx_iq_cal_v0.1_",
+            lo_freq
+        );
+    }
+    catch(const std::exception &e){
+        UHD_MSG(error) << "Failure in apply_rx_fe_corrections: " << e.what() << std::endl;
+    }
+}
diff --git a/host/lib/usrp/common/apply_corrections.hpp b/host/lib/usrp/common/apply_corrections.hpp
new file mode 100644
index 000000000..c516862d1
--- /dev/null
+++ b/host/lib/usrp/common/apply_corrections.hpp
@@ -0,0 +1,41 @@
+//
+// Copyright 2011 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_LIBUHD_USRP_COMMON_APPLY_CORRECTIONS_HPP
+#define INCLUDED_LIBUHD_USRP_COMMON_APPLY_CORRECTIONS_HPP
+
+#include <uhd/config.hpp>
+#include <uhd/property_tree.hpp>
+#include <string>
+
+namespace uhd{ namespace usrp{
+
+    void apply_tx_fe_corrections(
+        property_tree::sptr sub_tree, //starts at mboards/x
+        const std::string &slot, //name of dboard slot
+        const double tx_lo_freq //actual lo freq
+    );
+
+    void apply_rx_fe_corrections(
+        property_tree::sptr sub_tree, //starts at mboards/x
+        const std::string &slot, //name of dboard slot
+        const double rx_lo_freq //actual lo freq
+    );
+
+}} //namespace uhd::usrp
+
+#endif /* INCLUDED_LIBUHD_USRP_COMMON_APPLY_CORRECTIONS_HPP */
diff --git a/host/lib/usrp/cores/rx_frontend_core_200.cpp b/host/lib/usrp/cores/rx_frontend_core_200.cpp
index d42022947..d6396ef45 100644
--- a/host/lib/usrp/cores/rx_frontend_core_200.cpp
+++ b/host/lib/usrp/cores/rx_frontend_core_200.cpp
@@ -64,8 +64,8 @@ public:
     }
 
     void set_iq_balance(const std::complex<double> &cor){
-        _iface->poke32(REG_RX_FE_MAG_CORRECTION, fs_to_bits(std::abs(cor), 18));
-        _iface->poke32(REG_RX_FE_PHASE_CORRECTION, fs_to_bits(std::atan2(cor.real(), cor.imag()), 18));
+        _iface->poke32(REG_RX_FE_MAG_CORRECTION, fs_to_bits(std::abs(cor) - 1, 18));
+        _iface->poke32(REG_RX_FE_PHASE_CORRECTION, fs_to_bits(std::arg(cor)/6.28318531, 18));
     }
 
 private:
diff --git a/host/lib/usrp/cores/tx_frontend_core_200.cpp b/host/lib/usrp/cores/tx_frontend_core_200.cpp
index 327e8d344..b90281d9f 100644
--- a/host/lib/usrp/cores/tx_frontend_core_200.cpp
+++ b/host/lib/usrp/cores/tx_frontend_core_200.cpp
@@ -62,8 +62,8 @@ public:
     }
 
     void set_iq_balance(const std::complex<double> &cor){
-        _iface->poke32(REG_TX_FE_MAG_CORRECTION, fs_to_bits(std::abs(cor), 18));
-        _iface->poke32(REG_TX_FE_PHASE_CORRECTION, fs_to_bits(std::atan2(cor.real(), cor.imag()), 18));
+        _iface->poke32(REG_TX_FE_MAG_CORRECTION, fs_to_bits(std::abs(cor) - 1, 18));
+        _iface->poke32(REG_TX_FE_PHASE_CORRECTION, fs_to_bits(std::arg(cor)/6.28318531, 18));
     }
 
 private:
diff --git a/host/lib/usrp/dboard/db_rfx.cpp b/host/lib/usrp/dboard/db_rfx.cpp
index 3896534cd..58382f180 100644
--- a/host/lib/usrp/dboard/db_rfx.cpp
+++ b/host/lib/usrp/dboard/db_rfx.cpp
@@ -56,9 +56,9 @@ using namespace boost::assign;
 /***********************************************************************
  * The RFX Series constants
  **********************************************************************/
-static const std::vector<std::string> rfx_tx_antennas = list_of("TX/RX");
+static const std::vector<std::string> rfx_tx_antennas = list_of("TX/RX")("CAL");
 
-static const std::vector<std::string> rfx_rx_antennas = list_of("TX/RX")("RX2");
+static const std::vector<std::string> rfx_rx_antennas = list_of("TX/RX")("RX2")("CAL");
 
 static const uhd::dict<std::string, gain_range_t> rfx_rx_gain_ranges = map_list_of
     ("PGA0", gain_range_t(0, 70, 0.022))
@@ -271,10 +271,17 @@ void rfx_xcvr::set_rx_ant(const std::string &ant){
     assert_has(rfx_rx_antennas, ant, "rfx rx antenna name");
 
     //set the rx atr regs that change with antenna setting
-    this->get_iface()->set_atr_reg(
-        dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY,
-        _power_up | MIXER_ENB | ((ant == "TX/RX")? ANT_TXRX : ANT_RX2)
-    );
+    if (ant == "CAL") {
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY,     _power_up | ANT_TXRX  | MIXER_DIS);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, _power_up | ANT_TXRX  | MIXER_ENB);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY,     _power_up | MIXER_ENB | ANT_TXRX );
+    } 
+    else {
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY,     _power_up | ANT_XX | MIXER_DIS);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, _power_up | ANT_RX2| MIXER_ENB);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY,     _power_up | MIXER_ENB |
+            ((ant == "TX/RX")? ANT_TXRX : ANT_RX2));
+    }
 
     //shadow the setting
     _rx_ant = ant;
@@ -282,7 +289,16 @@ void rfx_xcvr::set_rx_ant(const std::string &ant){
 
 void rfx_xcvr::set_tx_ant(const std::string &ant){
     assert_has(rfx_tx_antennas, ant, "rfx tx antenna name");
-    //only one antenna option, do nothing
+
+    //set the tx atr regs that change with antenna setting
+    if (ant == "CAL") {
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY,     _power_up | ANT_RX | MIXER_ENB);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, _power_up | ANT_RX | MIXER_ENB);
+    } 
+    else {
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY,     _power_up | ANT_TX | MIXER_ENB);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, _power_up | ANT_TX | MIXER_ENB);
+    }
 }
 
 /***********************************************************************
diff --git a/host/lib/usrp/dboard/db_sbx_common.cpp b/host/lib/usrp/dboard/db_sbx_common.cpp
index 27b930f81..32b6730d5 100644
--- a/host/lib/usrp/dboard/db_sbx_common.cpp
+++ b/host/lib/usrp/dboard/db_sbx_common.cpp
@@ -216,35 +216,37 @@ void sbx_xcvr::update_atr(void){
     int rx_ld_led = get_locked(dboard_iface::UNIT_RX).to_bool() ? 0 : RX_LED_LD;
     int tx_ld_led = get_locked(dboard_iface::UNIT_TX).to_bool() ? 0 : TX_LED_LD;
     int rx_ant_led = _rx_ant == "TX/RX" ? RX_LED_RX1RX2 : 0;
-    int tx_ant_led = _rx_ant == "TX/RX" ? 0 : TX_LED_TXRX;
+    int tx_ant_led = _tx_ant == "TX/RX" ? 0 : TX_LED_TXRX;
 
     //setup the tx atr (this does not change with antenna)
     this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_IDLE,
         tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | ANT_XX | TX_MIXER_DIS);
-    this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY,
-        tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | ANT_TX | TX_MIXER_ENB);
-    this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX,
-        tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | ANT_TX | TX_MIXER_ENB);
 
     //setup the rx atr (this does not change with antenna)
     this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE,
         rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | ANT_XX | RX_MIXER_DIS);
+
+    //set the RX atr regs that change with antenna setting
+    this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY,
+        rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | RX_MIXER_ENB | 
+            ((_rx_ant != "RX2")? ANT_TXRX : ANT_RX2));
     this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY,
-        rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | ANT_RX2 | RX_MIXER_DIS);
+        rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | RX_MIXER_DIS |
+            ((_rx_ant == "CAL")? ANT_TXRX : ANT_RX2));
     this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX,
-        rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | ANT_RX2 | RX_MIXER_ENB);
+        rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | RX_MIXER_ENB |
+            ((_rx_ant == "CAL")? ANT_TXRX : ANT_RX2));
 
-    //set the atr regs that change with antenna setting
+    //set the TX atr regs that change with antenna setting
     this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_RX_ONLY,
         tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | TX_MIXER_DIS |
-            ((_rx_ant == "TX/RX")? ANT_RX : ANT_TX));
-    this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY,
-        rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | RX_MIXER_ENB | 
-            ((_rx_ant == "TX/RX")? ANT_TXRX : ANT_RX2));
-
-    UHD_LOGV(often) << boost::format(
-        "SBX RXONLY ATR REG: 0x%08x"
-    ) % (rx_pga0_iobits | RX_POWER_UP | RX_MIXER_ENB | ((_rx_ant == "TX/RX")? ANT_TXRX : ANT_RX2)) << std::endl;
+            ((_rx_ant != "RX2")? ANT_RX : ANT_TX));
+    this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY,
+        tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | TX_MIXER_ENB |
+            ((_tx_ant == "CAL")? ANT_RX : ANT_TX));
+    this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX,
+        tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | TX_MIXER_ENB |
+            ((_tx_ant == "CAL")? ANT_RX : ANT_TX));
 }
 
 void sbx_xcvr::set_rx_ant(const std::string &ant){
@@ -260,7 +262,12 @@ void sbx_xcvr::set_rx_ant(const std::string &ant){
 
 void sbx_xcvr::set_tx_ant(const std::string &ant){
     assert_has(sbx_tx_antennas, ant, "sbx tx antenna name");
-    //only one antenna option, do nothing
+
+    //shadow the setting
+    _tx_ant = ant;
+
+    //write the new antenna setting to atr regs
+    update_atr();
 }
 
 /***********************************************************************
diff --git a/host/lib/usrp/dboard/db_sbx_common.hpp b/host/lib/usrp/dboard/db_sbx_common.hpp
index c90cce456..8997350ae 100644
--- a/host/lib/usrp/dboard/db_sbx_common.hpp
+++ b/host/lib/usrp/dboard/db_sbx_common.hpp
@@ -113,9 +113,9 @@ static const freq_range_t sbx_enable_rx_lo_filter = list_of
     (range_t(0.4e9, 1.5e9))
 ;
 
-static const std::vector<std::string> sbx_tx_antennas = list_of("TX/RX");
+static const std::vector<std::string> sbx_tx_antennas = list_of("TX/RX")("CAL");
 
-static const std::vector<std::string> sbx_rx_antennas = list_of("TX/RX")("RX2");
+static const std::vector<std::string> sbx_rx_antennas = list_of("TX/RX")("RX2")("CAL");
 
 static const uhd::dict<std::string, gain_range_t> sbx_tx_gain_ranges = map_list_of
     ("PGA0", gain_range_t(0, 31.5, double(0.5)))
diff --git a/host/lib/usrp/dboard/db_wbx_simple.cpp b/host/lib/usrp/dboard/db_wbx_simple.cpp
index f46ea70d1..3d633a672 100644
--- a/host/lib/usrp/dboard/db_wbx_simple.cpp
+++ b/host/lib/usrp/dboard/db_wbx_simple.cpp
@@ -36,9 +36,9 @@ using namespace boost::assign;
 /***********************************************************************
  * The WBX Simple dboard constants
  **********************************************************************/
-static const std::vector<std::string> wbx_tx_antennas = list_of("TX/RX");
+static const std::vector<std::string> wbx_tx_antennas = list_of("TX/RX")("CAL");
 
-static const std::vector<std::string> wbx_rx_antennas = list_of("TX/RX")("RX2");
+static const std::vector<std::string> wbx_rx_antennas = list_of("TX/RX")("RX2")("CAL");
 
 /***********************************************************************
  * The WBX simple implementation
@@ -132,10 +132,28 @@ void wbx_simple::set_rx_ant(const std::string &ant){
     _rx_ant = ant;
 
     //write the new antenna setting to atr regs
-    this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, ((_rx_ant == "TX/RX")? ANT_TXRX : ANT_RX2), ANTSW_IO);
+    if (_rx_ant == "CAL") {
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY,     ANT_TXRX, ANTSW_IO);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, ANT_TXRX, ANTSW_IO);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY,     ANT_TXRX, ANTSW_IO);
+    } 
+    else {
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY,     ANT_RX2, ANTSW_IO);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, ANT_RX2, ANTSW_IO);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, ((_rx_ant == "TX/RX")? ANT_TXRX : ANT_RX2), ANTSW_IO);
+    }
 }
 
 void wbx_simple::set_tx_ant(const std::string &ant){
     assert_has(wbx_tx_antennas, ant, "wbx tx antenna name");
-    //only one antenna option, do nothing
+
+    //write the new antenna setting to atr regs
+    if (ant == "CAL") {
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY,     ANT_RX, ANTSW_IO);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, ANT_RX, ANTSW_IO);
+    } 
+    else {
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY,     ANT_TX, ANTSW_IO);
+        this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, ANT_TX, ANTSW_IO);
+    }
 }
diff --git a/host/lib/usrp/e100/e100_impl.cpp b/host/lib/usrp/e100/e100_impl.cpp
index c0a8f46f3..8b7756461 100644
--- a/host/lib/usrp/e100/e100_impl.cpp
+++ b/host/lib/usrp/e100/e100_impl.cpp
@@ -15,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
+#include "apply_corrections.hpp"
 #include "e100_impl.hpp"
 #include "e100_regs.hpp"
 #include <uhd/utils/msg.hpp>
@@ -259,13 +260,13 @@ e100_impl::e100_impl(const uhd::device_addr_t &device_addr){
         .set(true);
     _tree->create<std::complex<double> >(rx_fe_path / "iq_balance" / "value")
         .subscribe(boost::bind(&rx_frontend_core_200::set_iq_balance, _rx_fe, _1))
-        .set(std::complex<double>(0.0, 0.0));
+        .set(std::polar<double>(1.0, 0.0));
     _tree->create<std::complex<double> >(tx_fe_path / "dc_offset" / "value")
         .coerce(boost::bind(&tx_frontend_core_200::set_dc_offset, _tx_fe, _1))
         .set(std::complex<double>(0.0, 0.0));
     _tree->create<std::complex<double> >(tx_fe_path / "iq_balance" / "value")
         .subscribe(boost::bind(&tx_frontend_core_200::set_iq_balance, _tx_fe, _1))
-        .set(std::complex<double>(0.0, 0.0));
+        .set(std::polar<double>(1.0, 0.0));
 
     ////////////////////////////////////////////////////////////////////
     // create rx dsp control objects
@@ -374,6 +375,18 @@ e100_impl::e100_impl(const uhd::device_addr_t &device_addr){
         _dboard_iface, _tree->subtree(mb_path / "dboards/A")
     );
 
+    //bind frontend corrections to the dboard freq props
+    const fs_path db_tx_fe_path = mb_path / "dboards" / "A" / "tx_frontends";
+    BOOST_FOREACH(const std::string &name, _tree->list(db_tx_fe_path)){
+        _tree->access<double>(db_tx_fe_path / name / "freq" / "value")
+            .subscribe(boost::bind(&e100_impl::set_tx_fe_corrections, this, _1));
+    }
+    const fs_path db_rx_fe_path = mb_path / "dboards" / "A" / "rx_frontends";
+    BOOST_FOREACH(const std::string &name, _tree->list(db_rx_fe_path)){
+        _tree->access<double>(db_rx_fe_path / name / "freq" / "value")
+            .subscribe(boost::bind(&e100_impl::set_rx_fe_corrections, this, _1));
+    }
+
     //initialize io handling
     this->io_init();
 
@@ -450,3 +463,11 @@ void e100_impl::check_fpga_compat(void){
     }
     _tree->create<std::string>("/mboards/0/fpga_version").set(str(boost::format("%u.%u") % fpga_major % fpga_minor));
 }
+
+void e100_impl::set_rx_fe_corrections(const double lo_freq){
+    apply_rx_fe_corrections(this->get_tree()->subtree("/mboards/0"), "A", lo_freq);
+}
+
+void e100_impl::set_tx_fe_corrections(const double lo_freq){
+    apply_tx_fe_corrections(this->get_tree()->subtree("/mboards/0"), "A", lo_freq);
+}
diff --git a/host/lib/usrp/e100/e100_impl.hpp b/host/lib/usrp/e100/e100_impl.hpp
index f3e481b93..2ea890375 100644
--- a/host/lib/usrp/e100/e100_impl.hpp
+++ b/host/lib/usrp/e100/e100_impl.hpp
@@ -130,6 +130,8 @@ private:
     void update_clock_source(const std::string &);
     uhd::sensor_value_t get_ref_locked(void);
     void check_fpga_compat(void);
+    void set_rx_fe_corrections(const double);
+    void set_tx_fe_corrections(const double);
 
 };
 
diff --git a/host/lib/usrp/multi_usrp.cpp b/host/lib/usrp/multi_usrp.cpp
index 1110f5ebd..6fd60fb6f 100644
--- a/host/lib/usrp/multi_usrp.cpp
+++ b/host/lib/usrp/multi_usrp.cpp
@@ -50,10 +50,15 @@ static void do_samp_rate_warning_message(
 }
 
 static void do_tune_freq_warning_message(
-    double target_freq,
+    const tune_request_t &tune_req,
     double actual_freq,
     const std::string &xx
 ){
+    //forget the warning when manual policy
+    if (tune_req.dsp_freq_policy == tune_request_t::POLICY_MANUAL) return;
+    if (tune_req.rf_freq_policy == tune_request_t::POLICY_MANUAL) return;
+
+    const double target_freq = tune_req.target_freq;
     static const double max_allowed_error = 1.0; //Hz
     if (std::abs(target_freq - actual_freq) > max_allowed_error){
         UHD_MSG(warning) << boost::format(
@@ -486,7 +491,7 @@ public:
 
     tune_result_t set_rx_freq(const tune_request_t &tune_request, size_t chan){
         tune_result_t r = tune_xx_subdev_and_dsp(RX_SIGN, _tree->subtree(rx_dsp_root(chan)), _tree->subtree(rx_rf_fe_root(chan)), tune_request);
-        do_tune_freq_warning_message(tune_request.target_freq, get_rx_freq(chan), "RX");
+        do_tune_freq_warning_message(tune_request, get_rx_freq(chan), "RX");
         return r;
     }
 
@@ -634,7 +639,7 @@ public:
 
     tune_result_t set_tx_freq(const tune_request_t &tune_request, size_t chan){
         tune_result_t r = tune_xx_subdev_and_dsp(TX_SIGN, _tree->subtree(tx_dsp_root(chan)), _tree->subtree(tx_rf_fe_root(chan)), tune_request);
-        do_tune_freq_warning_message(tune_request.target_freq, get_tx_freq(chan), "TX");
+        do_tune_freq_warning_message(tune_request, get_tx_freq(chan), "TX");
         return r;
     }
 
diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp
index bb3bfc7e4..87e5596a3 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -17,6 +17,7 @@
 
 #include "usrp2_impl.hpp"
 #include "fw_common.h"
+#include "apply_corrections.hpp"
 #include <uhd/utils/log.hpp>
 #include <uhd/utils/msg.hpp>
 #include <uhd/exception.hpp>
@@ -473,13 +474,13 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr){
             .set(true);
         _tree->create<std::complex<double> >(rx_fe_path / "iq_balance" / "value")
             .subscribe(boost::bind(&rx_frontend_core_200::set_iq_balance, _mbc[mb].rx_fe, _1))
-            .set(std::complex<double>(0.0, 0.0));
+            .set(std::polar<double>(1.0, 0.0));
         _tree->create<std::complex<double> >(tx_fe_path / "dc_offset" / "value")
             .coerce(boost::bind(&tx_frontend_core_200::set_dc_offset, _mbc[mb].tx_fe, _1))
             .set(std::complex<double>(0.0, 0.0));
         _tree->create<std::complex<double> >(tx_fe_path / "iq_balance" / "value")
             .subscribe(boost::bind(&tx_frontend_core_200::set_iq_balance, _mbc[mb].tx_fe, _1))
-            .set(std::complex<double>(0.0, 0.0));
+            .set(std::polar<double>(1.0, 0.0));
 
         ////////////////////////////////////////////////////////////////
         // create rx dsp control objects
@@ -600,6 +601,18 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr){
             rx_db_eeprom.id, tx_db_eeprom.id, gdb_eeprom.id,
             _mbc[mb].dboard_iface, _tree->subtree(mb_path / "dboards/A")
         );
+
+        //bind frontend corrections to the dboard freq props
+        const fs_path db_tx_fe_path = mb_path / "dboards" / "A" / "tx_frontends";
+        BOOST_FOREACH(const std::string &name, _tree->list(db_tx_fe_path)){
+            _tree->access<double>(db_tx_fe_path / name / "freq" / "value")
+                .subscribe(boost::bind(&usrp2_impl::set_tx_fe_corrections, this, mb, _1));
+        }
+        const fs_path db_rx_fe_path = mb_path / "dboards" / "A" / "rx_frontends";
+        BOOST_FOREACH(const std::string &name, _tree->list(db_rx_fe_path)){
+            _tree->access<double>(db_rx_fe_path / name / "freq" / "value")
+                .subscribe(boost::bind(&usrp2_impl::set_rx_fe_corrections, this, mb, _1));
+        }
     }
 
     //initialize io handling
@@ -653,6 +666,14 @@ sensor_value_t usrp2_impl::get_ref_locked(const std::string &mb){
     return sensor_value_t("Ref", lock, "locked", "unlocked");
 }
 
+void usrp2_impl::set_rx_fe_corrections(const std::string &mb, const double lo_freq){
+    apply_rx_fe_corrections(this->get_tree()->subtree("/mboards/" + mb), "A", lo_freq);
+}
+
+void usrp2_impl::set_tx_fe_corrections(const std::string &mb, const double lo_freq){
+    apply_tx_fe_corrections(this->get_tree()->subtree("/mboards/" + mb), "A", lo_freq);
+}
+
 #include <boost/math/special_functions/round.hpp>
 #include <boost/math/special_functions/sign.hpp>
 
diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp
index 535397d84..278dc713e 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.hpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.hpp
@@ -106,6 +106,9 @@ private:
     uhd::sensor_value_t get_mimo_locked(const std::string &);
     uhd::sensor_value_t get_ref_locked(const std::string &);
 
+    void set_rx_fe_corrections(const std::string &mb, const double);
+    void set_tx_fe_corrections(const std::string &mb, const double);
+
     //device properties interface
     uhd::property_tree::sptr get_tree(void) const{
         return _tree;
diff --git a/host/lib/utils/CMakeLists.txt b/host/lib/utils/CMakeLists.txt
index 19dde9a56..b50e91299 100644
--- a/host/lib/utils/CMakeLists.txt
+++ b/host/lib/utils/CMakeLists.txt
@@ -128,6 +128,7 @@ SET_SOURCE_FILES_PROPERTIES(
 # Append sources
 ########################################################################
 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
diff --git a/host/lib/utils/csv.cpp b/host/lib/utils/csv.cpp
new file mode 100644
index 000000000..2ffa70196
--- /dev/null
+++ b/host/lib/utils/csv.cpp
@@ -0,0 +1,52 @@
+//
+// Copyright 2011 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/csv.hpp>
+#include <boost/foreach.hpp>
+
+using namespace uhd;
+
+csv::rows_type csv::to_rows(std::istream &input){
+    csv::rows_type rows;
+    std::string line;
+    //for each line in the input stream
+    while (std::getline(input, line)){
+        csv::row_type row(1, "");
+        bool in_quote = false;
+        char last_ch, next_ch = ' ';
+        //for each character in the line
+        BOOST_FOREACH(char ch, line){
+            last_ch = next_ch;
+            next_ch = ch;
+            //catch a quote character and change the state
+            //we handle double quotes by checking last_ch
+            if (ch == '"'){
+                in_quote = not in_quote;
+                if (last_ch != '"') continue;
+            }
+            //a comma not inside quotes is a column delimiter
+            if (not in_quote and ch == ','){
+                row.push_back("");
+                continue;
+            }
+            //if we got here we record the character
+            row.back() += ch;
+        }
+        rows.push_back(row);
+    }
+    return rows;
+}
diff --git a/host/lib/utils/paths.cpp b/host/lib/utils/paths.cpp
index a3dd377e5..4fc877d5d 100644
--- a/host/lib/utils/paths.cpp
+++ b/host/lib/utils/paths.cpp
@@ -16,6 +16,7 @@
 //
 
 #include <uhd/config.hpp>
+#include <uhd/utils/paths.hpp>
 #include <boost/tokenizer.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/foreach.hpp>
@@ -23,6 +24,8 @@
 #include <cstdlib>
 #include <string>
 #include <vector>
+#include <cstdlib> //getenv
+#include <cstdio>  //P_tmpdir
 
 namespace fs = boost::filesystem;
 
@@ -79,3 +82,27 @@ std::vector<fs::path> get_module_paths(void){
     paths.push_back(get_uhd_pkg_data_path() / "modules");
     return paths;
 }
+
+/***********************************************************************
+ * Implement the functions in paths.hpp
+ **********************************************************************/
+std::string uhd::get_tmp_path(void){
+    const char *tmp_path = std::getenv("TMP");
+    if (tmp_path != NULL) return tmp_path;
+
+    #ifdef P_tmpdir
+    if (P_tmpdir != NULL) return P_tmpdir;
+    #endif
+
+    return "/tmp";
+}
+
+std::string uhd::get_app_path(void){
+    const char *appdata_path = std::getenv("APPDATA");
+    if (appdata_path != NULL) return appdata_path;
+
+    const char *home_path = std::getenv("HOME");
+    if (home_path != NULL) return home_path;
+
+    return uhd::get_tmp_path();
+}
diff --git a/host/utils/CMakeLists.txt b/host/utils/CMakeLists.txt
index 1a0396ad3..430b49c47 100644
--- a/host/utils/CMakeLists.txt
+++ b/host/utils/CMakeLists.txt
@@ -21,6 +21,9 @@
 SET(util_runtime_sources
     uhd_find_devices.cpp
     uhd_usrp_probe.cpp
+    uhd_cal_rx_iq_balance.cpp
+    uhd_cal_tx_dc_offset.cpp
+    uhd_cal_tx_iq_balance.cpp
 )
 
 #for each source: build an executable and install
diff --git a/host/utils/uhd_cal_rx_iq_balance.cpp b/host/utils/uhd_cal_rx_iq_balance.cpp
new file mode 100644
index 000000000..da9ccbdb3
--- /dev/null
+++ b/host/utils/uhd_cal_rx_iq_balance.cpp
@@ -0,0 +1,240 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "usrp_cal_utils.hpp"
+#include <uhd/utils/thread_priority.hpp>
+#include <uhd/utils/safe_main.hpp>
+#include <uhd/utils/paths.hpp>
+#include <uhd/utils/algorithm.hpp>
+#include <uhd/usrp/multi_usrp.hpp>
+#include <boost/program_options.hpp>
+#include <boost/format.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <iostream>
+#include <complex>
+#include <cmath>
+#include <ctime>
+
+namespace po = boost::program_options;
+
+/***********************************************************************
+ * Transmit thread
+ **********************************************************************/
+static void tx_thread(uhd::usrp::multi_usrp::sptr usrp, const double tx_wave_ampl){
+    uhd::set_thread_priority_safe();
+
+    //create a transmit streamer
+    uhd::stream_args_t stream_args("fc32"); //complex floats
+    uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
+
+    //setup variables and allocate buffer
+    uhd::tx_metadata_t md;
+    md.has_time_spec = false;
+    std::vector<std::complex<float> > buff(tx_stream->get_max_num_samps()*10);
+
+    //fill buff and send until interrupted
+    while (not boost::this_thread::interruption_requested()){
+        for (size_t i = 0; i < buff.size(); i++){
+            buff[i] = float(tx_wave_ampl);
+        }
+        tx_stream->send(&buff.front(), buff.size(), md);
+    }
+
+    //send a mini EOB packet
+    md.end_of_burst = true;
+    tx_stream->send("", 0, md);
+}
+
+/***********************************************************************
+ * Tune RX and TX routine
+ **********************************************************************/
+static double tune_rx_and_tx(uhd::usrp::multi_usrp::sptr usrp, const double rx_lo_freq, const double tx_offset){
+    //tune the receiver with no cordic
+    uhd::tune_request_t rx_tune_req(rx_lo_freq);
+    rx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
+    rx_tune_req.dsp_freq = 0;
+    usrp->set_rx_freq(rx_tune_req);
+
+    //tune the transmitter with no cordic
+    uhd::tune_request_t tx_tune_req(usrp->get_rx_freq() - tx_offset);
+    tx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
+    tx_tune_req.dsp_freq = 0;
+    usrp->set_tx_freq(tx_tune_req);
+
+    //wait for the LOs to become locked
+    boost::this_thread::sleep(boost::posix_time::milliseconds(50));
+    boost::system_time start = boost::get_system_time();
+    while (not usrp->get_tx_sensor("lo_locked").to_bool() or not usrp->get_rx_sensor("lo_locked").to_bool()){
+        if (boost::get_system_time() > start + boost::posix_time::milliseconds(100)){
+            throw std::runtime_error("timed out waiting for TX and/or RX LO to lock");
+        }
+    }
+
+    return usrp->get_rx_freq();
+}
+
+/***********************************************************************
+ * Main
+ **********************************************************************/
+int UHD_SAFE_MAIN(int argc, char *argv[]){
+    std::string args;
+    double tx_wave_ampl, tx_offset;
+    double freq_start, freq_stop, freq_step;
+    size_t nsamps;
+
+    po::options_description desc("Allowed options");
+    desc.add_options()
+        ("help", "help message")
+        ("verbose", "enable some verbose")
+        ("args", po::value<std::string>(&args)->default_value(""), "device address args [default = \"\"]")
+        ("tx_wave_ampl", po::value<double>(&tx_wave_ampl)->default_value(0.7), "Transmit wave amplitude in counts")
+        ("tx_offset", po::value<double>(&tx_offset)->default_value(.9344e6), "TX LO offset from the RX LO in Hz")
+        ("freq_start", po::value<double>(&freq_start), "Frequency start in Hz (do not specify for default)")
+        ("freq_stop", po::value<double>(&freq_stop), "Frequency stop in Hz (do not specify for default)")
+        ("freq_step", po::value<double>(&freq_step)->default_value(default_freq_step), "Step size for LO sweep in Hz")
+        ("nsamps", po::value<size_t>(&nsamps)->default_value(default_num_samps), "Samples per data capture")
+    ;
+
+    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("USRP Generate RX IQ Balance Calibration Table %s") % desc << std::endl;
+        std::cout <<
+            "This application measures leakage between RX and TX on an XCVR daughterboard to self-calibrate.\n"
+            << 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);
+
+    //set the antennas to cal
+    if (not uhd::has(usrp->get_rx_antennas(), "CAL") or not uhd::has(usrp->get_tx_antennas(), "CAL")){
+        throw std::runtime_error("This board does not have the CAL antenna option, cannot self-calibrate.");
+    }
+    usrp->set_rx_antenna("CAL");
+    usrp->set_tx_antenna("CAL");
+
+    //set optimum defaults
+    set_optimum_defaults(usrp);
+
+    //create a receive streamer
+    uhd::stream_args_t stream_args("fc32"); //complex floats
+    uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
+
+    //create a transmitter thread
+    boost::thread_group threads;
+    threads.create_thread(boost::bind(&tx_thread, usrp, tx_wave_ampl));
+
+    //re-usable buffer for samples
+    std::vector<std::complex<float> > buff;
+
+    //store the results here
+    std::vector<result_t> results;
+
+    if (not vm.count("freq_start")) freq_start = usrp->get_rx_freq_range().start() + 50e6;
+    if (not vm.count("freq_stop")) freq_stop = usrp->get_rx_freq_range().stop() - 50e6;
+
+    for (double rx_lo_i = freq_start; rx_lo_i <= freq_stop; rx_lo_i += freq_step){
+        const double rx_lo = tune_rx_and_tx(usrp, rx_lo_i, tx_offset);
+
+        //frequency constants for this tune event
+        const double actual_rx_rate = usrp->get_rx_rate();
+        const double actual_tx_freq = usrp->get_tx_freq();
+        const double actual_rx_freq = usrp->get_rx_freq();
+        const double bb_tone_freq = actual_tx_freq - actual_rx_freq;
+        const double bb_imag_freq = -bb_tone_freq;
+
+        //capture initial uncorrected value
+        usrp->set_rx_iq_balance(std::polar<double>(1.0, 0.0));
+        capture_samples(usrp, rx_stream, buff, nsamps);
+        const double initial_suppression = compute_tone_dbrms(buff, bb_tone_freq/actual_rx_rate) - compute_tone_dbrms(buff, bb_imag_freq/actual_rx_rate);
+
+        //bounds and results from searching
+        std::complex<double> best_correction;
+        double phase_corr_start = -.3, phase_corr_stop = .3, phase_corr_step;
+        double ampl_corr_start = -.3, ampl_corr_stop = .3, ampl_corr_step;
+        double best_suppression = 0, best_phase_corr = 0, best_ampl_corr = 0;
+
+        for (size_t i = 0; i < num_search_iters; i++){
+
+            phase_corr_step = (phase_corr_stop - phase_corr_start)/(num_search_steps-1);
+            ampl_corr_step = (ampl_corr_stop - ampl_corr_start)/(num_search_steps-1);
+
+            for (double phase_corr = phase_corr_start; phase_corr <= phase_corr_stop + phase_corr_step/2; phase_corr += phase_corr_step){
+            for (double ampl_corr = ampl_corr_start; ampl_corr <= ampl_corr_stop + ampl_corr_step/2; ampl_corr += ampl_corr_step){
+
+                const std::complex<double> correction = std::polar(ampl_corr+1, phase_corr*tau);
+                usrp->set_rx_iq_balance(correction);
+
+                //receive some samples
+                capture_samples(usrp, rx_stream, buff, nsamps);
+
+                const double tone_dbrms = compute_tone_dbrms(buff, bb_tone_freq/actual_rx_rate);
+                const double imag_dbrms = compute_tone_dbrms(buff, bb_imag_freq/actual_rx_rate);
+                const double suppression = tone_dbrms - imag_dbrms;
+
+                if (suppression > best_suppression){
+                    best_correction = correction;
+                    best_suppression = suppression;
+                    best_phase_corr = phase_corr;
+                    best_ampl_corr = ampl_corr;
+                }
+
+            }}
+
+            //std::cout << "best_phase_corr " << best_phase_corr << std::endl;
+            //std::cout << "best_ampl_corr " << best_ampl_corr << std::endl;
+            //std::cout << "best_suppression " << best_suppression << std::endl;
+
+            phase_corr_start = best_phase_corr - phase_corr_step;
+            phase_corr_stop = best_phase_corr + phase_corr_step;
+            ampl_corr_start = best_ampl_corr - ampl_corr_step;
+            ampl_corr_stop = best_ampl_corr + ampl_corr_step;
+        }
+
+        if (best_suppression > 30){ //most likely valid, keep result
+            result_t result;
+            result.freq = rx_lo;
+            result.real_corr = best_correction.real();
+            result.imag_corr = best_correction.imag();
+            result.best = best_suppression;
+            result.delta = best_suppression - initial_suppression;
+            results.push_back(result);
+            if (vm.count("verbose")){
+                std::cout << boost::format("RX IQ: %f MHz: best suppression %f dB, corrected %f dB") % (rx_lo/1e6) % result.best % result.delta << std::endl;
+            }
+            else std::cout << "." << std::flush;
+        }
+
+    }
+    std::cout << std::endl;
+
+    //stop the transmitter
+    threads.interrupt_all();
+    threads.join_all();
+
+    store_results(usrp, results, "RX", "rx", "iq");
+
+    return 0;
+}
diff --git a/host/utils/uhd_cal_tx_dc_offset.cpp b/host/utils/uhd_cal_tx_dc_offset.cpp
new file mode 100644
index 000000000..af5b60d14
--- /dev/null
+++ b/host/utils/uhd_cal_tx_dc_offset.cpp
@@ -0,0 +1,238 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "usrp_cal_utils.hpp"
+#include <uhd/utils/thread_priority.hpp>
+#include <uhd/utils/safe_main.hpp>
+#include <uhd/utils/paths.hpp>
+#include <uhd/utils/algorithm.hpp>
+#include <uhd/usrp/multi_usrp.hpp>
+#include <boost/program_options.hpp>
+#include <boost/format.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <iostream>
+#include <complex>
+#include <ctime>
+
+namespace po = boost::program_options;
+
+/***********************************************************************
+ * Transmit thread
+ **********************************************************************/
+static void tx_thread(uhd::usrp::multi_usrp::sptr usrp, const double tx_wave_freq, const double tx_wave_ampl){
+    uhd::set_thread_priority_safe();
+
+    //create a transmit streamer
+    uhd::stream_args_t stream_args("fc32"); //complex floats
+    uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
+
+    //setup variables and allocate buffer
+    uhd::tx_metadata_t md;
+    md.has_time_spec = false;
+    std::vector<std::complex<float> > buff(tx_stream->get_max_num_samps()*10);
+
+    //values for the wave table lookup
+    size_t index = 0;
+    const double tx_rate = usrp->get_tx_rate();
+    const size_t step = boost::math::iround(wave_table_len * tx_wave_freq/tx_rate);
+    wave_table table(tx_wave_ampl);
+
+    //fill buff and send until interrupted
+    while (not boost::this_thread::interruption_requested()){
+        for (size_t i = 0; i < buff.size(); i++){
+            buff[i] = table(index += step);
+        }
+        tx_stream->send(&buff.front(), buff.size(), md);
+    }
+
+    //send a mini EOB packet
+    md.end_of_burst = true;
+    tx_stream->send("", 0, md);
+}
+
+/***********************************************************************
+ * Tune RX and TX routine
+ **********************************************************************/
+static double tune_rx_and_tx(uhd::usrp::multi_usrp::sptr usrp, const double tx_lo_freq, const double rx_offset){
+    //tune the transmitter with no cordic
+    uhd::tune_request_t tx_tune_req(tx_lo_freq);
+    tx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
+    tx_tune_req.dsp_freq = 0;
+    usrp->set_tx_freq(tx_tune_req);
+
+    //tune the receiver
+    usrp->set_rx_freq(usrp->get_tx_freq() - rx_offset);
+
+    //wait for the LOs to become locked
+    boost::this_thread::sleep(boost::posix_time::milliseconds(50));
+    boost::system_time start = boost::get_system_time();
+    while (not usrp->get_tx_sensor("lo_locked").to_bool() or not usrp->get_rx_sensor("lo_locked").to_bool()){
+        if (boost::get_system_time() > start + boost::posix_time::milliseconds(100)){
+            throw std::runtime_error("timed out waiting for TX and/or RX LO to lock");
+        }
+    }
+
+    return usrp->get_tx_freq();
+}
+
+/***********************************************************************
+ * Main
+ **********************************************************************/
+int UHD_SAFE_MAIN(int argc, char *argv[]){
+    std::string args;
+    double tx_wave_freq, tx_wave_ampl, rx_offset;
+    double freq_start, freq_stop, freq_step;
+    size_t nsamps;
+
+    po::options_description desc("Allowed options");
+    desc.add_options()
+        ("help", "help message")
+        ("verbose", "enable some verbose")
+        ("args", po::value<std::string>(&args)->default_value(""), "device address args [default = \"\"]")
+        ("tx_wave_freq", po::value<double>(&tx_wave_freq)->default_value(507.123e3), "Transmit wave frequency in Hz")
+        ("tx_wave_ampl", po::value<double>(&tx_wave_ampl)->default_value(0.7), "Transmit wave amplitude in counts")
+        ("rx_offset", po::value<double>(&rx_offset)->default_value(.9344e6), "RX LO offset from the TX LO in Hz")
+        ("freq_start", po::value<double>(&freq_start), "Frequency start in Hz (do not specify for default)")
+        ("freq_stop", po::value<double>(&freq_stop), "Frequency stop in Hz (do not specify for default)")
+        ("freq_step", po::value<double>(&freq_step)->default_value(default_freq_step), "Step size for LO sweep in Hz")
+        ("nsamps", po::value<size_t>(&nsamps)->default_value(default_num_samps), "Samples per data capture")
+    ;
+
+    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("USRP Generate TX DC Offset Calibration Table %s") % desc << std::endl;
+        std::cout <<
+            "This application measures leakage between RX and TX on an XCVR daughterboard to self-calibrate.\n"
+            << 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);
+
+    //set the antennas to cal
+    if (not uhd::has(usrp->get_rx_antennas(), "CAL") or not uhd::has(usrp->get_tx_antennas(), "CAL")){
+        throw std::runtime_error("This board does not have the CAL antenna option, cannot self-calibrate.");
+    }
+    usrp->set_rx_antenna("CAL");
+    usrp->set_tx_antenna("CAL");
+
+    //set optimum defaults
+    set_optimum_defaults(usrp);
+
+    //create a receive streamer
+    uhd::stream_args_t stream_args("fc32"); //complex floats
+    uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
+
+    //create a transmitter thread
+    boost::thread_group threads;
+    threads.create_thread(boost::bind(&tx_thread, usrp, tx_wave_freq, tx_wave_ampl));
+
+    //re-usable buffer for samples
+    std::vector<std::complex<float> > buff;
+
+    //store the results here
+    std::vector<result_t> results;
+
+    if (not vm.count("freq_start")) freq_start = usrp->get_tx_freq_range().start() + 50e6;
+    if (not vm.count("freq_stop")) freq_stop = usrp->get_tx_freq_range().stop() - 50e6;
+
+    for (double tx_lo_i = freq_start; tx_lo_i <= freq_stop; tx_lo_i += freq_step){
+        const double tx_lo = tune_rx_and_tx(usrp, tx_lo_i, rx_offset);
+
+        //frequency constants for this tune event
+        const double actual_rx_rate = usrp->get_rx_rate();
+        const double actual_tx_freq = usrp->get_tx_freq();
+        const double actual_rx_freq = usrp->get_rx_freq();
+        const double bb_dc_freq = actual_tx_freq - actual_rx_freq;
+
+        //capture initial uncorrected value
+        usrp->set_tx_dc_offset(std::complex<double>(0, 0));
+        capture_samples(usrp, rx_stream, buff, nsamps);
+        const double initial_dc_dbrms = compute_tone_dbrms(buff, bb_dc_freq/actual_rx_rate);
+
+        //bounds and results from searching
+        double dc_i_start = -.01, dc_i_stop = .01, dc_i_step;
+        double dc_q_start = -.01, dc_q_stop = .01, dc_q_step;
+        double lowest_offset = 0, best_dc_i = 0, best_dc_q = 0;
+
+        for (size_t i = 0; i < num_search_iters; i++){
+
+            dc_i_step = (dc_i_stop - dc_i_start)/(num_search_steps-1);
+            dc_q_step = (dc_q_stop - dc_q_start)/(num_search_steps-1);
+
+            for (double dc_i = dc_i_start; dc_i <= dc_i_stop + dc_i_step/2; dc_i += dc_i_step){
+            for (double dc_q = dc_q_start; dc_q <= dc_q_stop + dc_q_step/2; dc_q += dc_q_step){
+
+                const std::complex<double> correction(dc_i, dc_q);
+                usrp->set_tx_dc_offset(correction);
+
+                //receive some samples
+                capture_samples(usrp, rx_stream, buff, nsamps);
+
+                const double dc_dbrms = compute_tone_dbrms(buff, bb_dc_freq/actual_rx_rate);
+
+                if (dc_dbrms < lowest_offset){
+                    lowest_offset = dc_dbrms;
+                    best_dc_i = dc_i;
+                    best_dc_q = dc_q;
+                }
+
+            }}
+
+            //std::cout << "best_dc_i " << best_dc_i << std::endl;
+            //std::cout << "best_dc_q " << best_dc_q << std::endl;
+            //std::cout << "lowest_offset " << lowest_offset << std::endl;
+
+            dc_i_start = best_dc_i - dc_i_step;
+            dc_i_stop = best_dc_i + dc_i_step;
+            dc_q_start = best_dc_q - dc_q_step;
+            dc_q_stop = best_dc_q + dc_q_step;
+        }
+
+        if (lowest_offset < initial_dc_dbrms){ //most likely valid, keep result
+            result_t result;
+            result.freq = tx_lo;
+            result.real_corr = best_dc_i;
+            result.imag_corr = best_dc_q;
+            result.best = lowest_offset;
+            result.delta = initial_dc_dbrms - lowest_offset;
+            results.push_back(result);
+            if (vm.count("verbose")){
+                std::cout << boost::format("TX DC: %f MHz: lowest offset %f dB, corrected %f dB") % (tx_lo/1e6) % result.best % result.delta << std::endl;
+            }
+            else std::cout << "." << std::flush;
+        }
+
+    }
+    std::cout << std::endl;
+
+    //stop the transmitter
+    threads.interrupt_all();
+    threads.join_all();
+
+    store_results(usrp, results, "TX", "tx", "dc");
+
+    return 0;
+}
diff --git a/host/utils/uhd_cal_tx_iq_balance.cpp b/host/utils/uhd_cal_tx_iq_balance.cpp
new file mode 100644
index 000000000..ff965e040
--- /dev/null
+++ b/host/utils/uhd_cal_tx_iq_balance.cpp
@@ -0,0 +1,243 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "usrp_cal_utils.hpp"
+#include <uhd/utils/thread_priority.hpp>
+#include <uhd/utils/safe_main.hpp>
+#include <uhd/utils/paths.hpp>
+#include <uhd/utils/algorithm.hpp>
+#include <uhd/usrp/multi_usrp.hpp>
+#include <boost/program_options.hpp>
+#include <boost/format.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/math/special_functions/round.hpp>
+#include <iostream>
+#include <complex>
+#include <ctime>
+
+namespace po = boost::program_options;
+
+/***********************************************************************
+ * Transmit thread
+ **********************************************************************/
+static void tx_thread(uhd::usrp::multi_usrp::sptr usrp, const double tx_wave_freq, const double tx_wave_ampl){
+    uhd::set_thread_priority_safe();
+
+    //create a transmit streamer
+    uhd::stream_args_t stream_args("fc32"); //complex floats
+    uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
+
+    //setup variables and allocate buffer
+    uhd::tx_metadata_t md;
+    md.has_time_spec = false;
+    std::vector<std::complex<float> > buff(tx_stream->get_max_num_samps()*10);
+
+    //values for the wave table lookup
+    size_t index = 0;
+    const double tx_rate = usrp->get_tx_rate();
+    const size_t step = boost::math::iround(wave_table_len * tx_wave_freq/tx_rate);
+    wave_table table(tx_wave_ampl);
+
+    //fill buff and send until interrupted
+    while (not boost::this_thread::interruption_requested()){
+        for (size_t i = 0; i < buff.size(); i++){
+            buff[i] = table(index += step);
+        }
+        tx_stream->send(&buff.front(), buff.size(), md);
+    }
+
+    //send a mini EOB packet
+    md.end_of_burst = true;
+    tx_stream->send("", 0, md);
+}
+
+/***********************************************************************
+ * Tune RX and TX routine
+ **********************************************************************/
+static double tune_rx_and_tx(uhd::usrp::multi_usrp::sptr usrp, const double tx_lo_freq, const double rx_offset){
+    //tune the transmitter with no cordic
+    uhd::tune_request_t tx_tune_req(tx_lo_freq);
+    tx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
+    tx_tune_req.dsp_freq = 0;
+    usrp->set_tx_freq(tx_tune_req);
+
+    //tune the receiver
+    usrp->set_rx_freq(usrp->get_tx_freq() - rx_offset);
+
+    //wait for the LOs to become locked
+    boost::this_thread::sleep(boost::posix_time::milliseconds(50));
+    boost::system_time start = boost::get_system_time();
+    while (not usrp->get_tx_sensor("lo_locked").to_bool() or not usrp->get_rx_sensor("lo_locked").to_bool()){
+        if (boost::get_system_time() > start + boost::posix_time::milliseconds(100)){
+            throw std::runtime_error("timed out waiting for TX and/or RX LO to lock");
+        }
+    }
+
+    return usrp->get_tx_freq();
+}
+
+/***********************************************************************
+ * Main
+ **********************************************************************/
+int UHD_SAFE_MAIN(int argc, char *argv[]){
+    std::string args;
+    double tx_wave_freq, tx_wave_ampl, rx_offset;
+    double freq_start, freq_stop, freq_step;
+    size_t nsamps;
+
+    po::options_description desc("Allowed options");
+    desc.add_options()
+        ("help", "help message")
+        ("verbose", "enable some verbose")
+        ("args", po::value<std::string>(&args)->default_value(""), "device address args [default = \"\"]")
+        ("tx_wave_freq", po::value<double>(&tx_wave_freq)->default_value(507.123e3), "Transmit wave frequency in Hz")
+        ("tx_wave_ampl", po::value<double>(&tx_wave_ampl)->default_value(0.7), "Transmit wave amplitude in counts")
+        ("rx_offset", po::value<double>(&rx_offset)->default_value(.9344e6), "RX LO offset from the TX LO in Hz")
+        ("freq_start", po::value<double>(&freq_start), "Frequency start in Hz (do not specify for default)")
+        ("freq_stop", po::value<double>(&freq_stop), "Frequency stop in Hz (do not specify for default)")
+        ("freq_step", po::value<double>(&freq_step)->default_value(default_freq_step), "Step size for LO sweep in Hz")
+        ("nsamps", po::value<size_t>(&nsamps)->default_value(default_num_samps), "Samples per data capture")
+    ;
+
+    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("USRP Generate TX IQ Balance Calibration Table %s") % desc << std::endl;
+        std::cout <<
+            "This application measures leakage between RX and TX on an XCVR daughterboard to self-calibrate.\n"
+            << 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);
+
+    //set the antennas to cal
+    if (not uhd::has(usrp->get_rx_antennas(), "CAL") or not uhd::has(usrp->get_tx_antennas(), "CAL")){
+        throw std::runtime_error("This board does not have the CAL antenna option, cannot self-calibrate.");
+    }
+    usrp->set_rx_antenna("CAL");
+    usrp->set_tx_antenna("CAL");
+
+    //set optimum defaults
+    set_optimum_defaults(usrp);
+
+    //create a receive streamer
+    uhd::stream_args_t stream_args("fc32"); //complex floats
+    uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
+
+    //create a transmitter thread
+    boost::thread_group threads;
+    threads.create_thread(boost::bind(&tx_thread, usrp, tx_wave_freq, tx_wave_ampl));
+
+    //re-usable buffer for samples
+    std::vector<std::complex<float> > buff;
+
+    //store the results here
+    std::vector<result_t> results;
+
+    if (not vm.count("freq_start")) freq_start = usrp->get_tx_freq_range().start() + 50e6;
+    if (not vm.count("freq_stop")) freq_stop = usrp->get_tx_freq_range().stop() - 50e6;
+
+    for (double tx_lo_i = freq_start; tx_lo_i <= freq_stop; tx_lo_i += freq_step){
+        const double tx_lo = tune_rx_and_tx(usrp, tx_lo_i, rx_offset);
+
+        //frequency constants for this tune event
+        const double actual_rx_rate = usrp->get_rx_rate();
+        const double actual_tx_freq = usrp->get_tx_freq();
+        const double actual_rx_freq = usrp->get_rx_freq();
+        const double bb_tone_freq = actual_tx_freq + tx_wave_freq - actual_rx_freq;
+        const double bb_imag_freq = actual_tx_freq - tx_wave_freq - actual_rx_freq;
+
+        //capture initial uncorrected value
+        usrp->set_tx_iq_balance(std::polar<double>(1.0, 0.0));
+        capture_samples(usrp, rx_stream, buff, nsamps);
+        const double initial_suppression = compute_tone_dbrms(buff, bb_tone_freq/actual_rx_rate) - compute_tone_dbrms(buff, bb_imag_freq/actual_rx_rate);
+
+        //bounds and results from searching
+        std::complex<double> best_correction;
+        double phase_corr_start = -.3, phase_corr_stop = .3, phase_corr_step;
+        double ampl_corr_start = -.3, ampl_corr_stop = .3, ampl_corr_step;
+        double best_suppression = 0, best_phase_corr = 0, best_ampl_corr = 0;
+
+        for (size_t i = 0; i < num_search_iters; i++){
+
+            phase_corr_step = (phase_corr_stop - phase_corr_start)/(num_search_steps-1);
+            ampl_corr_step = (ampl_corr_stop - ampl_corr_start)/(num_search_steps-1);
+
+            for (double phase_corr = phase_corr_start; phase_corr <= phase_corr_stop + phase_corr_step/2; phase_corr += phase_corr_step){
+            for (double ampl_corr = ampl_corr_start; ampl_corr <= ampl_corr_stop + ampl_corr_step/2; ampl_corr += ampl_corr_step){
+
+                const std::complex<double> correction = std::polar(ampl_corr+1, phase_corr*tau);
+                usrp->set_tx_iq_balance(correction);
+
+                //receive some samples
+                capture_samples(usrp, rx_stream, buff, nsamps);
+
+                const double tone_dbrms = compute_tone_dbrms(buff, bb_tone_freq/actual_rx_rate);
+                const double imag_dbrms = compute_tone_dbrms(buff, bb_imag_freq/actual_rx_rate);
+                const double suppression = tone_dbrms - imag_dbrms;
+
+                if (suppression > best_suppression){
+                    best_correction = correction;
+                    best_suppression = suppression;
+                    best_phase_corr = phase_corr;
+                    best_ampl_corr = ampl_corr;
+                }
+
+            }}
+
+            //std::cout << "best_phase_corr " << best_phase_corr << std::endl;
+            //std::cout << "best_ampl_corr " << best_ampl_corr << std::endl;
+            //std::cout << "best_suppression " << best_suppression << std::endl;
+
+            phase_corr_start = best_phase_corr - phase_corr_step;
+            phase_corr_stop = best_phase_corr + phase_corr_step;
+            ampl_corr_start = best_ampl_corr - ampl_corr_step;
+            ampl_corr_stop = best_ampl_corr + ampl_corr_step;
+        }
+
+        if (best_suppression > 30){ //most likely valid, keep result
+            result_t result;
+            result.freq = tx_lo;
+            result.real_corr = best_correction.real();
+            result.imag_corr = best_correction.imag();
+            result.best = best_suppression;
+            result.delta = best_suppression - initial_suppression;
+            results.push_back(result);
+            if (vm.count("verbose")){
+                std::cout << boost::format("TX IQ: %f MHz: best suppression %f dB, corrected %f dB") % (tx_lo/1e6) % result.best % result.delta << std::endl;
+            }
+            else std::cout << "." << std::flush;
+        }
+
+    }
+    std::cout << std::endl;
+
+    //stop the transmitter
+    threads.interrupt_all();
+    threads.join_all();
+
+    store_results(usrp, results, "TX", "tx", "iq");
+
+    return 0;
+}
diff --git a/host/utils/usrp_cal_utils.hpp b/host/utils/usrp_cal_utils.hpp
new file mode 100644
index 000000000..0faaf9a84
--- /dev/null
+++ b/host/utils/usrp_cal_utils.hpp
@@ -0,0 +1,225 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/utils/paths.hpp>
+#include <uhd/property_tree.hpp>
+#include <uhd/usrp/multi_usrp.hpp>
+#include <uhd/usrp/dboard_eeprom.hpp>
+#include <boost/filesystem.hpp>
+#include <iostream>
+#include <vector>
+#include <complex>
+#include <cmath>
+#include <fstream>
+
+namespace fs = boost::filesystem;
+
+struct result_t{double freq, real_corr, imag_corr, best, delta;};
+
+/***********************************************************************
+ * Constants
+ **********************************************************************/
+static const double tau = 6.28318531;
+static const double alpha = 0.0001; //very tight iir filter
+static const size_t wave_table_len = 8192;
+static const size_t num_search_steps = 5;
+static const size_t num_search_iters = 7;
+static const size_t skip_initial_samps = 20;
+static const double default_freq_step = 7.3e6;
+static const size_t default_num_samps = 10000;
+
+/***********************************************************************
+ * Set standard defaults for devices
+ **********************************************************************/
+static inline void set_optimum_defaults(uhd::usrp::multi_usrp::sptr usrp){
+    uhd::property_tree::sptr tree = usrp->get_device()->get_tree();
+
+    const uhd::fs_path mb_path = "/mboards/0";
+    const std::string mb_name = tree->access<std::string>(mb_path / "name").get();
+    if (mb_name.find("USRP2") != std::string::npos){
+        usrp->set_tx_rate(12.5e6);
+        usrp->set_rx_rate(12.5e6);
+    }
+    else if (mb_name.find("B100") != std::string::npos){
+        usrp->set_tx_rate(4e6);
+        usrp->set_rx_rate(4e6);
+    }
+    else if (mb_name.find("E10") != std::string::npos){
+        usrp->set_tx_rate(4e6);
+        usrp->set_rx_rate(8e6);
+    }
+    else{
+        throw std::runtime_error("self-calibration is not supported for this hardware");
+    }
+
+    const uhd::fs_path tx_fe_path = "/mboards/0/dboards/A/tx_frontends/0";
+    const std::string tx_name = tree->access<std::string>(tx_fe_path / "name").get();
+    if (tx_name.find("WBX") != std::string::npos or tx_name.find("SBX") != std::string::npos){
+        usrp->set_tx_gain(0);
+    }
+    else{
+        throw std::runtime_error("self-calibration is not supported for this hardware");
+    }
+
+    const uhd::fs_path rx_fe_path = "/mboards/0/dboards/A/tx_frontends/0";
+    const std::string rx_name = tree->access<std::string>(rx_fe_path / "name").get();
+    if (rx_name.find("WBX") != std::string::npos or rx_name.find("SBX") != std::string::npos){
+        usrp->set_rx_gain(25);
+    }
+    else{
+        throw std::runtime_error("self-calibration is not supported for this hardware");
+    }
+
+}
+
+/***********************************************************************
+ * Sinusoid wave table
+ **********************************************************************/
+class wave_table{
+public:
+    wave_table(const double ampl){
+        _table.resize(wave_table_len);
+        for (size_t i = 0; i < wave_table_len; i++){
+            _table[i] = std::complex<float>(std::polar(ampl, (tau*i)/wave_table_len));
+        }
+    }
+
+    inline std::complex<float> operator()(const size_t index) const{
+        return _table[index % wave_table_len];
+    }
+
+private:
+    std::vector<std::complex<float> > _table;
+};
+
+/***********************************************************************
+ * Compute power of a tone
+ **********************************************************************/
+static inline double compute_tone_dbrms(
+    const std::vector<std::complex<float> > &samples,
+    const double freq //freq is fractional
+){
+    //shift the samples so the tone at freq is down at DC
+    std::vector<std::complex<float> > shifted(samples.size() - skip_initial_samps);
+    for (size_t i = 0; i < shifted.size(); i++){
+        shifted[i] = samples[i+skip_initial_samps] * std::complex<float>(std::polar(1.0, -freq*tau*i));
+    }
+
+    //filter the samples with a narrow low pass
+    std::complex<float> iir_output = 0, iir_last = 0;
+    double output = 0;
+    for (size_t i = 0; i < shifted.size(); i++){
+        iir_output = float(alpha) * shifted[i] + float(1-alpha)*iir_last;
+        iir_last = iir_output;
+        output += std::abs(iir_output);
+    }
+
+    return 20*std::log10(output/shifted.size());
+}
+
+/***********************************************************************
+ * Write a dat file
+ **********************************************************************/
+static inline void write_samples_to_file(
+    const std::vector<std::complex<float> > &samples, const std::string &file
+){
+    std::ofstream outfile(file.c_str(), std::ofstream::binary);
+    outfile.write((const char*)&samples.front(), samples.size()*sizeof(std::complex<float>));
+    outfile.close();
+}
+
+/***********************************************************************
+ * Store data to file
+ **********************************************************************/
+static void store_results(
+    uhd::usrp::multi_usrp::sptr usrp,
+    const std::vector<result_t> &results,
+    const std::string &XX,
+    const std::string &xx,
+    const std::string &what
+){
+    //extract eeprom serial
+    uhd::property_tree::sptr tree = usrp->get_device()->get_tree();
+    const uhd::fs_path db_path = "/mboards/0/dboards/A/" + xx + "_eeprom";
+    const uhd::usrp::dboard_eeprom_t db_eeprom = tree->access<uhd::usrp::dboard_eeprom_t>(db_path).get();
+    if (db_eeprom.serial.empty()) throw std::runtime_error(XX + " dboard has empty serial!");
+
+    //make the calibration file path
+    fs::path cal_data_path = fs::path(uhd::get_app_path()) / ".uhd";
+    fs::create_directory(cal_data_path);
+    cal_data_path = cal_data_path / "cal";
+    fs::create_directory(cal_data_path);
+    cal_data_path = cal_data_path / str(boost::format("%s_%s_cal_v0.1_%s.csv") % xx % what % db_eeprom.serial);
+    if (fs::exists(cal_data_path)){
+        fs::rename(cal_data_path, cal_data_path.string() + str(boost::format(".%d") % time(NULL)));
+    }
+
+    //fill the calibration file
+    std::ofstream cal_data(cal_data_path.string().c_str());
+    cal_data << boost::format("name, %s Frontend Calibration\n") % XX;
+    cal_data << boost::format("serial, %s\n") % db_eeprom.serial;
+    cal_data << boost::format("timestamp, %d\n") % time(NULL);
+    cal_data << boost::format("version, 0, 1\n");
+    cal_data << boost::format("DATA STARTS HERE\n");
+    cal_data << "lo_frequency, correction_real, correction_imag, measured, delta\n";
+
+    for (size_t i = 0; i < results.size(); i++){
+        cal_data
+            << results[i].freq << ", "
+            << results[i].real_corr << ", "
+            << results[i].imag_corr << ", "
+            << results[i].best << ", "
+            << results[i].delta << "\n"
+        ;
+    }
+
+    std::cout << "wrote cal data to " << cal_data_path << std::endl;
+}
+
+/***********************************************************************
+ * Data capture routine
+ **********************************************************************/
+static void capture_samples(
+    uhd::usrp::multi_usrp::sptr usrp,
+    uhd::rx_streamer::sptr rx_stream,
+    std::vector<std::complex<float> > &buff,
+    const size_t nsamps_requested
+){
+    buff.resize(nsamps_requested);
+    uhd::rx_metadata_t md;
+
+    uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE);
+    stream_cmd.num_samps = buff.size();
+    stream_cmd.stream_now = true;
+    usrp->issue_stream_cmd(stream_cmd);
+    const size_t num_rx_samps = rx_stream->recv(&buff.front(), buff.size(), md);
+
+    //validate the received data
+    if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE){
+        throw std::runtime_error(str(boost::format(
+            "Unexpected error code 0x%x"
+        ) % md.error_code));
+    }
+    //we can live if all the data didnt come in
+    if (num_rx_samps > buff.size()/2){
+        buff.resize(num_rx_samps);
+        return;
+    }
+    if (num_rx_samps != buff.size()){
+        throw std::runtime_error("did not get all the samples requested");
+    }
+}