BladeRF library compiles

1 files changed, 1745 insertions, 0 deletions

diff --git a/Radio/HW/BladeRF/common/src/dc_calibration.c b/Radio/HW/BladeRF/common/src/dc_calibration.c
new file mode 100644
index 0000000..c746c3c
--- /dev/null
+++ b/Radio/HW/BladeRF/common/src/dc_calibration.c
@@ -0,0 +1,1745 @@
+/**
+ * This file is part of the bladeRF project:
+ *   http://www.github.com/nuand/bladeRF
+ *
+ * Copyright (c) 2015 Nuand LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include <limits.h>
+
+#define _USE_MATH_DEFINES /* Required for MSVC */
+#include <math.h>
+
+#include <libbladeRF.h>
+
+#include "dc_calibration.h"
+#include "conversions.h"
+
+struct complexf {
+    float i;
+    float q;
+};
+
+struct gain_mode {
+    bladerf_lna_gain lna_gain;
+    int rxvga1, rxvga2;
+};
+/*******************************************************************************
+ * Debug items
+ ******************************************************************************/
+
+/* Enable this to print diagnostic and debug information */
+//#define ENABLE_DC_CALIBRATION_DEBUG
+//#define ENABLE_DC_CALIBRATION_VERBOSE
+
+#ifndef PR_DBG
+#   ifdef ENABLE_DC_CALIBRATION_DEBUG
+#      define PR_DBG(...) fprintf(stderr, "  " __VA_ARGS__)
+#   else
+#      define PR_DBG(...) do {} while (0)
+#   endif
+#endif
+
+#ifndef PR_VERBOSE
+#   ifdef ENABLE_DC_CALIBRATION_VERBOSE
+#       define PR_VERBOSE(...) fprintf(stderr, "  " __VA_ARGS__)
+#   else
+#       define PR_VERBOSE(...) do {} while (0)
+#   endif
+#endif
+
+/*******************************************************************************
+ * Debug routines for saving samples
+ ******************************************************************************/
+
+//#define ENABLE_SAVE_SC16Q11
+#ifdef ENABLE_SAVE_SC16Q11
+static void save_sc16q11(const char *name, int16_t *samples, unsigned int count)
+{
+    FILE *out = fopen(name, "wb");
+    if (!out) {
+        return;
+    }
+
+    fwrite(samples, 2 * sizeof(samples[0]), count, out);
+    fclose(out);
+}
+#else
+#   define save_sc16q11(name, samples, count) do {} while (0)
+#endif
+
+//#define ENABLE_SAVE_COMPLEXF
+#ifdef ENABLE_SAVE_COMPLEXF
+static void save_complexf(const char *name, struct complexf *samples,
+                          unsigned int count)
+{
+    unsigned int n;
+    FILE *out = fopen(name, "wb");
+    if (!out) {
+        return;
+    }
+
+    for (n = 0; n < count; n++) {
+        fwrite(&samples[n].i, sizeof(samples[n].i), 1, out);
+        fwrite(&samples[n].q, sizeof(samples[n].q), 1, out);
+    }
+
+    fclose(out);
+}
+#else
+#   define save_complexf(name, samples, count) do {} while (0)
+#endif
+
+
+/*******************************************************************************
+ * LMS6002D DC offset calibration
+ ******************************************************************************/
+
+/* We've found that running samples through the LMS6 tends to be required
+ * for the TX LPF calibration to converge */
+static inline int tx_lpf_dummy_tx(struct bladerf *dev)
+{
+    int status;
+    int retval = 0;
+    struct bladerf_metadata meta;
+    int16_t zero_sample[] = { 0, 0 };
+
+    bladerf_loopback loopback_backup;
+    struct bladerf_rational_rate sample_rate_backup;
+
+    memset(&meta, 0, sizeof(meta));
+
+    status = bladerf_get_loopback(dev, &loopback_backup);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_rational_sample_rate(dev, BLADERF_MODULE_TX,
+                                              &sample_rate_backup);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_loopback(dev, BLADERF_LB_BB_TXVGA1_RXVGA2);
+    if (status != 0) {
+        goto out;
+    }
+
+    status = bladerf_set_sample_rate(dev, BLADERF_MODULE_TX, 3000000, NULL);
+    if (status != 0) {
+        goto out;
+    }
+
+    status = bladerf_sync_config(dev, BLADERF_MODULE_TX,
+                                 BLADERF_FORMAT_SC16_Q11_META,
+                                 64, 16384, 16, 1000);
+    if (status != 0) {
+        goto out;
+    }
+
+    status = bladerf_enable_module(dev, BLADERF_MODULE_TX, true);
+    if (status != 0) {
+        goto out;
+    }
+
+    meta.flags = BLADERF_META_FLAG_TX_BURST_START |
+                 BLADERF_META_FLAG_TX_BURST_END   |
+                 BLADERF_META_FLAG_TX_NOW;
+
+    status = bladerf_sync_tx(dev, zero_sample, 1, &meta, 2000);
+    if (status != 0) {
+        goto out;
+    }
+
+out:
+    status = bladerf_enable_module(dev, BLADERF_MODULE_TX, false);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_rational_sample_rate(dev, BLADERF_MODULE_TX,
+                                              &sample_rate_backup, NULL);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_loopback(dev, loopback_backup);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    return retval;
+}
+
+static int cal_tx_lpf(struct bladerf *dev)
+{
+    int status;
+
+    status = tx_lpf_dummy_tx(dev);
+    if (status == 0) {
+        status = bladerf_calibrate_dc(dev, BLADERF_DC_CAL_TX_LPF);
+    }
+
+    return status;
+}
+
+int dc_calibration_lms6(struct bladerf *dev, const char *module_str)
+{
+    int status;
+    bladerf_cal_module module;
+
+    if (!strcasecmp(module_str, "all")) {
+        status = bladerf_calibrate_dc(dev, BLADERF_DC_CAL_LPF_TUNING);
+        if (status != 0) {
+            return status;
+        }
+
+        status = cal_tx_lpf(dev);
+        if (status != 0) {
+            return status;
+        }
+
+        status = bladerf_calibrate_dc(dev, BLADERF_DC_CAL_RX_LPF);
+        if (status != 0) {
+            return status;
+        }
+
+        status = bladerf_calibrate_dc(dev, BLADERF_DC_CAL_RXVGA2);
+    } else {
+        module = str_to_bladerf_cal_module(module_str);
+        if (module == BLADERF_DC_CAL_INVALID) {
+            return BLADERF_ERR_INVAL;
+        }
+
+        if (module == BLADERF_DC_CAL_TX_LPF) {
+            status = cal_tx_lpf(dev);
+        } else {
+            status = bladerf_calibrate_dc(dev, module);
+        }
+    }
+
+    return status;
+}
+
+
+
+/*******************************************************************************
+ * Shared utility routines
+ ******************************************************************************/
+
+/* Round float to int16_t */
+static inline int16_t float_to_int16(float val)
+{
+    if ((val - 0.5) <= INT16_MIN) {
+        return INT16_MIN;
+    }
+    if ((val + 0.5) >= INT16_MAX) {
+        return INT16_MAX;
+    }
+    return val >= 0 ? (int16_t)(val + 0.5) : (int16_t)(val - 0.5);
+}
+
+/* Convert ms to samples */
+#define MS_TO_SAMPLES(ms_, rate_) (\
+    (unsigned int) (ms_ * ((uint64_t) rate_) / 1000) \
+)
+
+/* RX samples, retrying if the machine is struggling to keep up. */
+static int rx_samples(struct bladerf *dev, int16_t *samples,
+                      unsigned int count, uint64_t *ts, uint64_t ts_inc)
+{
+    int status = 0;
+    struct bladerf_metadata meta;
+    int retry = 0;
+    const int max_retries = 10;
+    bool overrun = true;
+
+    memset(&meta, 0, sizeof(meta));
+    meta.timestamp = *ts;
+
+    while (status == 0 && overrun && retry < max_retries) {
+        meta.timestamp = *ts;
+        status = bladerf_sync_rx(dev, samples, count, &meta, 2000);
+
+        if (status == BLADERF_ERR_TIME_PAST) {
+            status = bladerf_get_timestamp(dev, BLADERF_MODULE_RX, ts);
+            if (status != 0) {
+                return status;
+            } else {
+                *ts += 20 * ts_inc;
+                retry++;
+                status = 0;
+            }
+        } else if (status == 0) {
+            overrun = (meta.flags & BLADERF_META_STATUS_OVERRUN) != 0;
+            if (overrun) {
+                *ts += count + ts_inc;
+                retry++;
+            }
+        } else {
+            return status;
+        }
+    }
+
+    if (retry >= max_retries) {
+        status = BLADERF_ERR_IO;
+    } else if (status == 0) {
+        *ts += count + ts_inc;
+    }
+
+    return status;
+}
+
+
+
+/*******************************************************************************
+ * RX DC offset calibration
+ ******************************************************************************/
+
+#define RX_CAL_RATE             (3000000)
+#define RX_CAL_BW               (1500000)
+#define RX_CAL_TS_INC           (MS_TO_SAMPLES(15, RX_CAL_RATE))
+#define RX_CAL_COUNT            (MS_TO_SAMPLES(5,  RX_CAL_RATE))
+
+#define RX_CAL_MAX_SWEEP_LEN    (2 * 2048 / 32) /* -2048 : 32 : 2048 */
+
+struct rx_cal {
+    struct bladerf *dev;
+
+    int16_t *samples;
+    unsigned int num_samples;
+
+    int16_t *corr_sweep;
+
+    uint64_t ts;
+
+    uint64_t tx_freq;
+};
+
+struct rx_cal_backup {
+    struct bladerf_rational_rate rational_sample_rate;
+    unsigned int bandwidth;
+    uint64_t tx_freq;
+};
+
+static int get_rx_cal_backup(struct bladerf *dev, struct rx_cal_backup *b)
+{
+    int status;
+
+    status = bladerf_get_rational_sample_rate(dev, BLADERF_MODULE_RX,
+                                              &b->rational_sample_rate);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_bandwidth(dev, BLADERF_MODULE_RX, &b->bandwidth);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_frequency(dev, BLADERF_MODULE_TX, &b->tx_freq);
+    if (status != 0) {
+        return status;
+    }
+
+    return status;
+}
+
+static int set_rx_cal_backup(struct bladerf *dev, struct rx_cal_backup *b)
+{
+    int status;
+    int retval = 0;
+
+    status = bladerf_set_rational_sample_rate(dev, BLADERF_MODULE_RX,
+                                              &b->rational_sample_rate, NULL);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_bandwidth(dev, BLADERF_MODULE_RX, b->bandwidth, NULL);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_frequency(dev, BLADERF_MODULE_TX, b->tx_freq);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    return retval;
+}
+
+/* Ensure TX >= 1 MHz away from the RX frequency to avoid any potential
+ * artifacts from the PLLs interfering with one another */
+static int rx_cal_update_frequency(struct rx_cal *cal, uint64_t rx_freq)
+{
+    int status = 0;
+    uint64_t f_diff;
+
+    if (rx_freq < cal->tx_freq) {
+        f_diff = cal->tx_freq - rx_freq;
+    } else {
+        f_diff = rx_freq - cal->tx_freq;
+    }
+
+    PR_DBG("Set F_RX = %u\n", rx_freq);
+    PR_DBG("F_diff(RX, TX) = %u\n", f_diff);
+
+    if (f_diff < 1000000) {
+        if (rx_freq >= (BLADERF_FREQUENCY_MIN + 1000000)) {
+            cal->tx_freq = rx_freq - 1000000;
+        } else {
+            cal->tx_freq = rx_freq + 1000000;
+        }
+
+        status = bladerf_set_frequency(cal->dev, BLADERF_MODULE_TX,
+                                       cal->tx_freq);
+        if (status != 0) {
+            return status;
+        }
+
+        PR_DBG("Adjusted TX frequency: %u\n", cal->tx_freq);
+    }
+
+    status = bladerf_set_frequency(cal->dev, BLADERF_MODULE_RX, rx_freq);
+    if (status != 0) {
+        return status;
+    }
+
+    cal->ts += RX_CAL_TS_INC;
+
+    return status;
+}
+
+static inline void sample_mean(int16_t *samples, size_t count,
+                               float *mean_i, float *mean_q)
+{
+    int64_t accum_i = 0;
+    int64_t accum_q = 0;
+
+    size_t n;
+
+
+    if (count == 0) {
+        assert(!"Invalid count (0) provided to sample_mean()");
+        *mean_i = 0;
+        *mean_q = 0;
+        return;
+    }
+
+    for (n = 0; n < (2 * count); n += 2) {
+        accum_i += samples[n];
+        accum_q += samples[n + 1];
+    }
+
+    *mean_i = ((float) accum_i) / count;
+    *mean_q = ((float) accum_q) / count;
+}
+
+static inline int set_rx_dc_corr(struct bladerf *dev, int16_t i, int16_t q)
+{
+    int status;
+
+    status = bladerf_set_correction(dev, BLADERF_MODULE_RX,
+                                    BLADERF_CORR_LMS_DCOFF_I, i);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_correction(dev, BLADERF_MODULE_RX,
+                                    BLADERF_CORR_LMS_DCOFF_Q, q);
+    return status;
+}
+
+/* Get the mean for one of the coarse estimate points. If it seems that this
+ * value might be (or close) causing us to clamp, adjust it and retry */
+static int rx_cal_coarse_means(struct rx_cal *cal, int16_t *corr_value,
+                               float *mean_i, float *mean_q)
+{
+    int status;
+    const int16_t mean_limit_high = 2000;
+    const int16_t mean_limit_low  = -mean_limit_high;
+    const int16_t corr_limit = 128;
+    bool retry = false;
+
+    do {
+        status = set_rx_dc_corr(cal->dev, *corr_value, *corr_value);
+        if (status != 0) {
+            return status;
+        }
+
+        status = rx_samples(cal->dev, cal->samples, cal->num_samples,
+                            &cal->ts, RX_CAL_TS_INC);
+        if (status != 0) {
+            return status;
+        }
+
+        sample_mean(cal->samples, cal->num_samples, mean_i, mean_q);
+
+        if (*mean_i > mean_limit_high || *mean_q > mean_limit_high ||
+            *mean_i < mean_limit_low  || *mean_q < mean_limit_low    ) {
+
+            if (*corr_value < 0) {
+                retry = (*corr_value <= -corr_limit);
+            } else {
+                retry = (*corr_value >= corr_limit);
+            }
+
+            if (retry) {
+                PR_DBG("Coarse estimate point Corr=%4d yields extreme means: "
+                       "(%4f, %4f). Retrying...\n",
+                       *corr_value, *mean_i, *mean_q);
+
+                *corr_value = *corr_value / 2;
+            }
+        } else {
+            retry = false;
+        }
+    } while (retry);
+
+    if (retry) {
+        PR_DBG("Non-ideal values are being used.\n");
+    }
+
+    return 0;
+}
+
+/* Estimate the DC correction values that yield zero DC offset via a linear
+ * approximation */
+static int rx_cal_coarse_estimate(struct rx_cal *cal,
+                                  int16_t *i_est, int16_t *q_est)
+{
+    int status;
+    int16_t x1 = -2048;
+    int16_t x2 = 2048;
+    float y1i, y1q, y2i, y2q;
+    float mi, mq;
+    float bi, bq;
+    float i_guess, q_guess;
+
+    status = rx_cal_coarse_means(cal, &x1, &y1i, &y1q);
+    if (status != 0) {
+        *i_est = 0;
+        *q_est = 0;
+        return status;
+    }
+
+    PR_VERBOSE("Means for x1=%d: y1i=%f, y1q=%f\n", x1, y1i, y1q);
+
+    status = rx_cal_coarse_means(cal, &x2, &y2i, &y2q);
+    if (status != 0) {
+        *i_est = 0;
+        *q_est = 0;
+        return status;
+    }
+
+    PR_VERBOSE("Means for x2: y2i=%f, y2q=%f\n", y2i, y2q);
+
+    mi = (y2i - y1i) / (x2 - x1);
+    mq = (y2q - y1q) / (x2 - x1);
+
+    bi = y1i - mi * x1;
+    bq = y1q - mq * x1;
+
+    PR_VERBOSE("mi=%f, bi=%f, mq=%f, bq=%f\n", mi, bi, mq, bq);
+
+    i_guess = -bi/mi + 0.5f;
+    if (i_guess < -2048) {
+        i_guess = -2048;
+    } else if (i_guess > 2048) {
+        i_guess = 2048;
+    }
+
+    q_guess = -bq/mq + 0.5f;
+    if (q_guess < -2048) {
+        q_guess = -2048;
+    } else if (q_guess > 2048) {
+        q_guess = 2048;
+    }
+
+    *i_est = (int16_t) i_guess;
+    *q_est = (int16_t) q_guess;
+
+    PR_DBG("Coarse estimate: I=%d, Q=%d\n", *i_est, *q_est);
+
+    return 0;
+}
+
+static void init_rx_cal_sweep(int16_t *corr, unsigned int *sweep_len,
+                              int16_t i_est, int16_t q_est)
+{
+    unsigned int actual_len = 0;
+    unsigned int i;
+
+    int16_t sweep_min, sweep_max, sweep_val;
+
+    /* LMS6002D RX DC calibrations have a limited range. libbladeRF throws away
+     * the lower 5 bits. */
+    const int16_t sweep_inc = 32;
+
+    const int16_t min_est = (i_est < q_est) ? i_est : q_est;
+    const int16_t max_est = (i_est > q_est) ? i_est : q_est;
+
+    sweep_min = min_est - 12 * 32;
+    if (sweep_min < -2048) {
+        sweep_min = -2048;
+    }
+
+    sweep_max = max_est + 12 * 32;
+    if (sweep_max > 2048) {
+        sweep_max = 2048;
+    }
+
+    /* Given that these lower bits are thrown away, it can be confusing to
+     * see that values change in their LSBs that don't matter. Therefore,
+     * we'll adjust to muliples of sweep_inc */
+    sweep_min = (sweep_min / 32) * 32;
+    sweep_max = (sweep_max / 32) * 32;
+
+
+    PR_DBG("Sweeping [%d : %d : %d]\n", sweep_min, sweep_inc, sweep_max);
+
+    sweep_val = sweep_min;
+    for (i = 0; sweep_val < sweep_max && i < RX_CAL_MAX_SWEEP_LEN; i++) {
+        corr[i] = sweep_val;
+        sweep_val += sweep_inc;
+        actual_len++;
+    }
+
+    *sweep_len = actual_len;
+}
+
+static int save_gains(struct rx_cal *cal, struct gain_mode *gain) {
+    int status;
+
+    status = bladerf_get_lna_gain(cal->dev, &gain->lna_gain);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_rxvga1(cal->dev, &gain->rxvga1);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_rxvga2(cal->dev, &gain->rxvga2);
+    if (status != 0) {
+        return status;
+    }
+
+    return status;
+}
+
+static int load_gains(struct rx_cal *cal, struct gain_mode *gain) {
+    int status;
+
+    status = bladerf_set_lna_gain(cal->dev, gain->lna_gain);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_rxvga1(cal->dev, gain->rxvga1);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_rxvga2(cal->dev, gain->rxvga2);
+    if (status != 0) {
+        return status;
+    }
+
+    return status;
+}
+
+static int rx_cal_dc_off(struct rx_cal *cal, struct gain_mode *gains,
+                        int16_t *dc_i, int16_t *dc_q)
+{
+    int status = BLADERF_ERR_UNEXPECTED;
+
+    float mean_i, mean_q;
+
+    status = load_gains(cal, gains);
+    if (status != 0) {
+        return status;
+    }
+
+    status = rx_samples(cal->dev, cal->samples, cal->num_samples,
+                        &cal->ts, RX_CAL_TS_INC);
+    if (status != 0) {
+        return status;
+    }
+
+    sample_mean(cal->samples, cal->num_samples, &mean_i, &mean_q);
+    *dc_i = float_to_int16(mean_i);
+    *dc_q = float_to_int16(mean_q);
+
+    return 0;
+}
+
+static int rx_cal_sweep(struct rx_cal *cal,
+                        int16_t *corr, unsigned int sweep_len,
+                        int16_t *result_i, int16_t *result_q,
+                        float *error_i,  float *error_q)
+{
+    int status = BLADERF_ERR_UNEXPECTED;
+    unsigned int n;
+
+    int16_t min_corr_i = 0;
+    int16_t min_corr_q = 0;
+
+    float mean_i, mean_q;
+    float min_val_i, min_val_q;
+
+    min_val_i = min_val_q = 2048;
+
+    for (n = 0; n < sweep_len; n++) {
+        status = set_rx_dc_corr(cal->dev, corr[n], corr[n]);
+        if (status != 0) {
+            return status;
+        }
+
+        status = rx_samples(cal->dev, cal->samples, cal->num_samples,
+                            &cal->ts, RX_CAL_TS_INC);
+        if (status != 0) {
+            return status;
+        }
+
+        sample_mean(cal->samples, cal->num_samples, &mean_i, &mean_q);
+
+        PR_VERBOSE("  Corr=%4d, Mean_I=%4.2f, Mean_Q=%4.2f\n",
+                   corr[n], mean_i, mean_q);
+
+        /* Not using fabs() to avoid adding a -lm dependency */
+        if (mean_i < 0) {
+            mean_i = -mean_i;
+        }
+
+        if (mean_q < 0) {
+            mean_q = -mean_q;
+        }
+
+        if (mean_i < min_val_i) {
+            min_val_i  = mean_i;
+            min_corr_i = corr[n];
+        }
+
+        if (mean_q < min_val_q) {
+            min_val_q  = mean_q;
+            min_corr_q = corr[n];
+        }
+    }
+
+    *result_i = min_corr_i;
+    *result_q = min_corr_q;
+    *error_i  = min_val_i;
+    *error_q  = min_val_q;
+
+    return 0;
+}
+
+static int perform_rx_cal(struct rx_cal *cal, struct dc_calibration_params *p)
+{
+    int status;
+    int16_t i_est, q_est;
+    unsigned int sweep_len = RX_CAL_MAX_SWEEP_LEN;
+    struct gain_mode saved_gains;
+
+    struct gain_mode agc_gains[] = {
+        { .lna_gain = BLADERF_LNA_GAIN_MAX, .rxvga1 = 30, .rxvga2 = 15 },  /* AGC Max Gain */
+        { .lna_gain = BLADERF_LNA_GAIN_MID, .rxvga1 = 30, .rxvga2 = 0  },  /* AGC Mid Gain */
+        { .lna_gain = BLADERF_LNA_GAIN_MID, .rxvga1 = 12, .rxvga2 = 0  }   /* AGC Min Gain */
+    };
+
+    status = rx_cal_update_frequency(cal, p->frequency);
+    if (status != 0) {
+        return status;
+    }
+
+    /* Get an initial guess at our correction values */
+    status = rx_cal_coarse_estimate(cal, &i_est, &q_est);
+    if (status != 0) {
+        return status;
+    }
+
+    /* Perform a finer sweep of correction values */
+    init_rx_cal_sweep(cal->corr_sweep, &sweep_len, i_est, q_est);
+
+    /* Advance our timestmap just to account for any time we may have lost */
+    cal->ts += RX_CAL_TS_INC;
+
+    status = rx_cal_sweep(cal, cal->corr_sweep, sweep_len,
+                          &p->corr_i, &p->corr_q,
+                          &p->error_i, &p->error_q);
+
+    if (status != 0) {
+        return status;
+    }
+
+    /* Apply the nominal correction values */
+    status = set_rx_dc_corr(cal->dev, p->corr_i, p->corr_q);
+    if (status != 0) {
+        return status;
+    }
+
+    bladerf_fpga_size fpga_size;
+    status = bladerf_get_fpga_size(cal->dev, &fpga_size);
+    if (status != 0) {
+        return status;
+    }
+
+    if (fpga_size != BLADERF_FPGA_40KLE &&
+         fpga_size != BLADERF_FPGA_115KLE) {
+        return 0;
+    }
+
+    /* Measure DC correction for AGC */
+    status = save_gains(cal, &saved_gains);
+    if (status != 0) {
+        return status;
+    }
+
+    status = rx_cal_dc_off(cal, &agc_gains[2], &p->min_dc_i, &p->min_dc_q);
+    if (status != 0) {
+        return status;
+    }
+
+    status = rx_cal_dc_off(cal, &agc_gains[1], &p->mid_dc_i, &p->mid_dc_q);
+    if (status != 0) {
+        return status;
+    }
+
+    status = rx_cal_dc_off(cal, &agc_gains[0], &p->max_dc_i, &p->max_dc_q);
+    if (status != 0) {
+        return status;
+    }
+
+    status = load_gains(cal, &saved_gains);
+
+    return status;
+}
+
+static int rx_cal_init_state(struct bladerf *dev,
+                             const struct rx_cal_backup *backup,
+                             struct rx_cal *state)
+{
+    int status;
+
+    state->dev = dev;
+
+    state->num_samples  = RX_CAL_COUNT;
+
+    state->samples = malloc(2 * sizeof(state->samples[0]) * RX_CAL_COUNT);
+    if (state->samples == NULL) {
+        return BLADERF_ERR_MEM;
+    }
+
+    state->corr_sweep = malloc(sizeof(state->corr_sweep[0]) * RX_CAL_MAX_SWEEP_LEN);
+    if (state->corr_sweep == NULL) {
+        return BLADERF_ERR_MEM;
+    }
+
+    state->tx_freq = backup->tx_freq;
+
+    status = bladerf_get_timestamp(dev, BLADERF_MODULE_RX, &state->ts);
+    if (status != 0) {
+        return status;
+    }
+
+    /* Schedule first RX well into the future */
+    state->ts += 20 * RX_CAL_TS_INC;
+
+    return status;
+}
+
+static int rx_cal_init(struct bladerf *dev)
+{
+    int status;
+
+    status = bladerf_set_sample_rate(dev, BLADERF_MODULE_RX, RX_CAL_RATE, NULL);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_bandwidth(dev, BLADERF_MODULE_RX, RX_CAL_BW, NULL);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_sync_config(dev, BLADERF_MODULE_RX,
+                                 BLADERF_FORMAT_SC16_Q11_META,
+                                 64, 16384, 16, 1000);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_enable_module(dev, BLADERF_MODULE_RX, true);
+    if (status != 0) {
+        return status;
+    }
+
+    return status;
+}
+
+int dc_calibration_rx(struct bladerf *dev,
+                      struct dc_calibration_params *params,
+                      size_t params_count, bool print_status)
+{
+    int status = 0;
+    int retval = 0;
+    struct rx_cal state;
+    struct rx_cal_backup backup;
+    size_t i;
+
+    memset(&state, 0, sizeof(state));
+
+    status = get_rx_cal_backup(dev, &backup);
+    if (status != 0) {
+        return status;
+    }
+
+    status = rx_cal_init(dev);
+    if (status != 0) {
+        goto out;
+    }
+
+    status = rx_cal_init_state(dev, &backup, &state);
+    if (status != 0) {
+        goto out;
+    }
+
+    for (i = 0; i < params_count && status == 0; i++) {
+        status = perform_rx_cal(&state, &params[i]);
+
+        if (status == 0 && print_status) {
+#           ifdef DEBUG_DC_CALIBRATION
+            const char sol = '\n';
+            const char eol = '\n';
+#           else
+            const char sol = '\r';
+            const char eol = '\0';
+#           endif
+            printf("%cCalibrated @ %10" PRIu64 " Hz: I=%4d (Error: %4.2f), "
+                   "Q=%4d (Error: %4.2f)      ",
+                   sol,
+                   params[i].frequency,
+                   params[i].corr_i, params[i].error_i,
+                   params[i].corr_q, params[i].error_q);
+            printf("DC-LUT: Max (I=%3d, Q=%3d) Mid (I=%3d, Q=%3d)"
+                   " Min (I=%3d, Q=%3d)%c",
+                       params[i].max_dc_i, params[i].max_dc_q, params[i].mid_dc_i, params[i].mid_dc_q,
+                       params[i].min_dc_i, params[i].min_dc_q, eol);
+            fflush(stdout);
+        }
+    }
+
+    if (print_status) {
+        putchar('\n');
+    }
+
+out:
+    free(state.samples);
+    free(state.corr_sweep);
+
+    retval = status;
+
+    status = bladerf_enable_module(dev, BLADERF_MODULE_RX, false);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = set_rx_cal_backup(dev, &backup);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    return retval;
+}
+
+
+
+/*******************************************************************************
+ * TX DC offset calibration
+ ******************************************************************************/
+
+#define TX_CAL_RATE     (4000000)
+
+#define TX_CAL_RX_BW    (3000000)
+#define TX_CAL_RX_LNA   (BLADERF_LNA_GAIN_MAX)
+#define TX_CAL_RX_VGA1  (25)
+#define TX_CAL_RX_VGA2  (0)
+
+#define TX_CAL_TX_BW    (1500000)
+
+#define TX_CAL_TS_INC   (MS_TO_SAMPLES(15, TX_CAL_RATE))
+#define TX_CAL_COUNT    (MS_TO_SAMPLES(5,  TX_CAL_RATE))
+
+#define TX_CAL_CORR_SWEEP_LEN (4096 / 16)   /* -2048:16:2048 */
+
+#define TX_CAL_DEFAULT_LB (BLADERF_LB_RF_LNA1)
+
+struct tx_cal_backup {
+    uint64_t rx_freq;
+    struct bladerf_rational_rate rx_sample_rate;
+    unsigned int rx_bandwidth;
+
+    bladerf_lna_gain rx_lna;
+    int rx_vga1;
+    int rx_vga2;
+
+    struct bladerf_rational_rate tx_sample_rate;
+    unsigned int tx_bandwidth;
+
+    bladerf_loopback loopback;
+};
+
+struct tx_cal {
+    struct bladerf *dev;
+    int16_t *samples;           /* Raw samples */
+    unsigned int num_samples;   /* Number of raw samples */
+    struct complexf *filt;      /* Filter state */
+    struct complexf *filt_out;  /* Filter output */
+    struct complexf *post_mix;  /* Post-filter, mixed to baseband */
+    int16_t *sweep;             /* Correction sweep */
+    float   *mag;               /* Magnitude results from sweep */
+    uint64_t ts;                /* Timestamp */
+    bladerf_loopback loopback;  /* Current loopback mode */
+    bool rx_low;                /* RX tuned lower than TX */
+};
+
+/* Filter used to isolate contribution of TX LO leakage in received
+ * signal. 15th order Equiripple FIR with Fs=4e6, Fpass=1, Fstop=1e6
+ */
+static const float tx_cal_filt[] = {
+    0.000327949366768f, 0.002460188536582f, 0.009842382390924f,
+    0.027274728394777f, 0.057835200476419f, 0.098632713294830f,
+    0.139062540460741f, 0.164562494987592f, 0.164562494987592f,
+    0.139062540460741f, 0.098632713294830f, 0.057835200476419f,
+    0.027274728394777f, 0.009842382390924f, 0.002460188536582f,
+    0.000327949366768f,
+};
+
+static const unsigned int tx_cal_filt_num_taps =
+    (sizeof(tx_cal_filt) / sizeof(tx_cal_filt[0]));
+
+static inline int set_tx_dc_corr(struct bladerf *dev, int16_t i, int16_t q)
+{
+    int status;
+
+    status = bladerf_set_correction(dev, BLADERF_MODULE_TX,
+                                    BLADERF_CORR_LMS_DCOFF_I, i);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_correction(dev, BLADERF_MODULE_TX,
+                                    BLADERF_CORR_LMS_DCOFF_Q, q);
+    return status;
+}
+
+static int get_tx_cal_backup(struct bladerf *dev, struct tx_cal_backup *b)
+{
+    int status;
+
+    status = bladerf_get_frequency(dev, BLADERF_MODULE_RX, &b->rx_freq);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_rational_sample_rate(dev, BLADERF_MODULE_RX,
+                                              &b->rx_sample_rate);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_bandwidth(dev, BLADERF_MODULE_RX, &b->rx_bandwidth);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_lna_gain(dev, &b->rx_lna);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_rxvga1(dev, &b->rx_vga1);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_rxvga2(dev, &b->rx_vga2);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_rational_sample_rate(dev, BLADERF_MODULE_TX,
+                                              &b->tx_sample_rate);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_get_loopback(dev, &b->loopback);
+
+    return status;
+}
+
+static int set_tx_cal_backup(struct bladerf *dev, struct tx_cal_backup *b)
+{
+    int status;
+    int retval = 0;
+
+    status = bladerf_set_loopback(dev, b->loopback);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_frequency(dev, BLADERF_MODULE_RX, b->rx_freq);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_rational_sample_rate(dev, BLADERF_MODULE_RX,
+                                              &b->rx_sample_rate, NULL);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_bandwidth(dev, BLADERF_MODULE_RX,
+                                   b->rx_bandwidth, NULL);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_lna_gain(dev, b->rx_lna);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_rxvga1(dev, b->rx_vga1);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_rxvga2(dev, b->rx_vga2);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_set_rational_sample_rate(dev, BLADERF_MODULE_TX,
+                                              &b->tx_sample_rate, NULL);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    return retval;
+}
+
+static int tx_cal_update_frequency(struct tx_cal *state, uint64_t freq)
+{
+    int status;
+    bladerf_loopback lb;
+    uint64_t rx_freq;
+
+    status = bladerf_set_frequency(state->dev, BLADERF_MODULE_TX, freq);
+    if (status != 0) {
+        return status;
+    }
+
+    rx_freq = freq - 1000000;
+    if (rx_freq < BLADERF_FREQUENCY_MIN) {
+        rx_freq = freq + 1000000;
+        state->rx_low = false;
+    } else {
+        state->rx_low = true;
+    }
+
+    status = bladerf_set_frequency(state->dev, BLADERF_MODULE_RX, rx_freq);
+    if (status != 0) {
+        return status;
+    }
+
+    if (freq < 1500000000) {
+        lb = BLADERF_LB_RF_LNA1;
+        PR_DBG("Switching to RF LNA1 loopback.\n");
+    } else {
+        lb = BLADERF_LB_RF_LNA2;
+        PR_DBG("Switching to RF LNA2 loopback.\n");
+    }
+
+    if (state->loopback != lb) {
+        status = bladerf_set_loopback(state->dev, lb);
+        if (status == 0) {
+            state->loopback = lb;
+        }
+    }
+
+    return status;
+}
+
+static int apply_tx_cal_settings(struct bladerf *dev)
+{
+    int status;
+
+    status = bladerf_set_sample_rate(dev, BLADERF_MODULE_RX, TX_CAL_RATE, NULL);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_bandwidth(dev, BLADERF_MODULE_RX, TX_CAL_RX_BW, NULL);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_lna_gain(dev, TX_CAL_RX_LNA);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_rxvga1(dev, TX_CAL_RX_VGA1);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_rxvga2(dev, TX_CAL_RX_VGA2);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_sample_rate(dev, BLADERF_MODULE_TX, TX_CAL_RATE, NULL);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_set_loopback(dev, TX_CAL_DEFAULT_LB);
+    if (status != 0) {
+        return status;
+    }
+
+    return status;
+}
+
+/* We just need to flush some zeros through the system to hole the DAC at
+ * 0+0j and remain there while letting it underrun. This alleviates the
+ * need to worry about continuously TX'ing zeros. */
+static int tx_cal_tx_init(struct bladerf *dev)
+{
+    int status;
+    int16_t zero_sample[] = { 0, 0 };
+    struct bladerf_metadata meta;
+
+    memset(&meta, 0, sizeof(meta));
+
+    status = bladerf_sync_config(dev, BLADERF_MODULE_TX,
+                                 BLADERF_FORMAT_SC16_Q11_META,
+                                 4, 16384, 2, 1000);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_enable_module(dev, BLADERF_MODULE_TX, true);
+    if (status != 0) {
+        return status;
+    }
+
+    meta.flags = BLADERF_META_FLAG_TX_BURST_START |
+                 BLADERF_META_FLAG_TX_BURST_END   |
+                 BLADERF_META_FLAG_TX_NOW;
+
+    status = bladerf_sync_tx(dev, &zero_sample, 1, &meta, 2000);
+    return status;
+}
+
+static int tx_cal_rx_init(struct bladerf *dev)
+{
+    int status;
+
+    status = bladerf_sync_config(dev, BLADERF_MODULE_RX,
+                                 BLADERF_FORMAT_SC16_Q11_META,
+                                 64, 16384, 32, 1000);
+    if (status != 0) {
+        return status;
+    }
+
+    status = bladerf_enable_module(dev, BLADERF_MODULE_RX, true);
+    return status;
+}
+
+static void tx_cal_state_deinit(struct tx_cal *cal)
+{
+    free(cal->sweep);
+    free(cal->mag);
+    free(cal->samples);
+    free(cal->filt);
+    free(cal->filt_out);
+    free(cal->post_mix);
+}
+
+/* This should be called immediately preceding the cal routines */
+static int tx_cal_state_init(struct bladerf *dev, struct tx_cal *cal)
+{
+    int status;
+
+    cal->dev = dev;
+    cal->num_samples = TX_CAL_COUNT;
+    cal->loopback = TX_CAL_DEFAULT_LB;
+
+    /* Interleaved SC16 Q11 samples */
+    cal->samples = malloc(2 * sizeof(cal->samples[0]) * cal->num_samples);
+    if (cal->samples == NULL) {
+        return BLADERF_ERR_MEM;
+    }
+
+    /* Filter state */
+    cal->filt = malloc(2 * sizeof(cal->filt[0]) * tx_cal_filt_num_taps);
+    if (cal->filt == NULL) {
+        return BLADERF_ERR_MEM;
+    }
+
+    /* Filter output */
+    cal->filt_out = malloc(sizeof(cal->filt_out[0]) * cal->num_samples);
+    if (cal->filt_out == NULL) {
+        return BLADERF_ERR_MEM;
+    }
+
+    /* Post-mix */
+    cal->post_mix = malloc(sizeof(cal->post_mix[0]) * cal->num_samples);
+    if (cal->post_mix == NULL) {
+        return BLADERF_ERR_MEM;
+    }
+
+    /* Correction sweep and results */
+    cal->sweep = malloc(sizeof(cal->sweep[0]) * TX_CAL_CORR_SWEEP_LEN);
+    if (cal->sweep == NULL) {
+        return BLADERF_ERR_MEM;
+    }
+
+    cal->mag = malloc(sizeof(cal->mag[0]) * TX_CAL_CORR_SWEEP_LEN);
+    if (cal->mag == NULL) {
+        return BLADERF_ERR_MEM;
+    }
+
+    /* Set initial RX in the future */
+    status = bladerf_get_timestamp(cal->dev, BLADERF_MODULE_RX, &cal->ts);
+    if (status == 0) {
+        cal->ts += 20 * TX_CAL_TS_INC;
+    }
+
+    return status;
+}
+
+/* Filter samples
+ *  Input:  state->post_mix
+ *  Output: state->filt_out
+ */
+static void tx_cal_filter(struct tx_cal *state)
+{
+    unsigned int n, m;
+    struct complexf *ins1, *ins2;
+    struct complexf *curr; /* Current filter state */
+    const struct complexf *filt_end = &state->filt[2 * tx_cal_filt_num_taps];
+
+    /* Reset filter state */
+    ins1 = &state->filt[0];
+    ins2 = &state->filt[tx_cal_filt_num_taps];
+    memset(state->filt, 0, 2 * sizeof(state->filt[0]) * tx_cal_filt_num_taps);
+
+    for (n = 0; n < state->num_samples; n++) {
+        /* Insert sample */
+        *ins1 = *ins2 = state->post_mix[n];
+
+        /* Convolve */
+        state->filt_out[n].i = 0;
+        state->filt_out[n].q = 0;
+        curr = ins2;
+
+        for (m = 0; m < tx_cal_filt_num_taps; m++, curr--) {
+            state->filt_out[n].i += tx_cal_filt[m] * curr->i;
+            state->filt_out[n].q += tx_cal_filt[m] * curr->q;
+        }
+
+        /* Update insertion points */
+        ins2++;
+        if (ins2 == filt_end) {
+            ins1 = &state->filt[0];
+            ins2 = &state->filt[tx_cal_filt_num_taps];
+        } else {
+            ins1++;
+        }
+
+    }
+}
+
+/* Deinterleave, scale, and mix with an -Fs/4 tone to shift TX DC offset out at
+ * Fs/4 to baseband.
+ *  Input:  state->samples
+ *  Output: state->post_mix
+ */
+static void tx_cal_mix(struct tx_cal *state)
+{
+    unsigned int n, m;
+    int mix_state;
+    float scaled_i, scaled_q;
+
+    /* Mix with -Fs/4 if RX is tuned "lower" than TX, and Fs/4 otherwise */
+    const int mix_state_inc = state->rx_low ? 1 : -1;
+    mix_state = 0;
+
+    for (n = 0, m = 0; n < (2 * state->num_samples); n += 2, m++) {
+        scaled_i = state->samples[n]   / 2048.0f;
+        scaled_q = state->samples[n+1] / 2048.0f;
+
+        switch (mix_state) {
+            case 0:
+                state->post_mix[m].i =  scaled_i;
+                state->post_mix[m].q =  scaled_q;
+                break;
+
+            case 1:
+                state->post_mix[m].i =  scaled_q;
+                state->post_mix[m].q = -scaled_i;
+                break;
+
+            case 2:
+                state->post_mix[m].i = -scaled_i;
+                state->post_mix[m].q = -scaled_q;
+                break;
+
+            case 3:
+                state->post_mix[m].i = -scaled_q;
+                state->post_mix[m].q =  scaled_i;
+                break;
+        }
+
+        mix_state = (mix_state + mix_state_inc) & 0x3;
+    }
+}
+
+static int tx_cal_avg_magnitude(struct tx_cal *state, float *avg_mag)
+{
+    int status;
+    const unsigned int start = (tx_cal_filt_num_taps + 1) / 2;
+    unsigned int n;
+    float accum;
+
+    /* Fetch samples at the current settings */
+    status = rx_samples(state->dev, state->samples, state->num_samples,
+                        &state->ts, TX_CAL_TS_INC);
+    if (status != 0) {
+        return status;
+    }
+
+    /* Deinterleave & mix TX's DC offset contribution to baseband */
+    tx_cal_mix(state);
+
+    /* Filter out everything other than the TX DC offset's contribution */
+    tx_cal_filter(state);
+
+    /* Compute the power (magnitude^2 to alleviate need for square root).
+     * We skip samples here to account for the group delay of the filter;
+     * the initial samples will be ramping up. */
+    accum = 0;
+    for (n = start; n < state->num_samples; n++) {
+        const struct complexf *s = &state->filt_out[n];
+        const float m = (float) sqrt(s->i * s->i + s->q * s->q);
+        accum += m;
+    }
+
+    *avg_mag = (accum / (state->num_samples - start));
+
+    /* Scale this back up to DAC/ADC counts, just for convenience */
+    *avg_mag *= 2048.0;
+
+    return status;
+}
+
+/* Apply the correction value and read the TX DC offset magnitude */
+static int tx_cal_measure_correction(struct tx_cal *state,
+                                     bladerf_correction c,
+                                     int16_t value, float *mag)
+{
+    int status;
+
+    status = bladerf_set_correction(state->dev, BLADERF_MODULE_TX, c, value);
+    if (status != 0) {
+        return status;
+    }
+
+    state->ts += TX_CAL_TS_INC;
+
+    status = tx_cal_avg_magnitude(state, mag);
+    if (status == 0) {
+        PR_VERBOSE("  Corr=%5d, Avg_magnitude=%f\n", value, *mag);
+    }
+
+    return status;
+}
+
+static int tx_cal_get_corr(struct tx_cal *state, bool i_ch,
+                           int16_t *corr_value, float *error_value)
+{
+    int status;
+    unsigned int n;
+    int16_t corr;
+    float mag[4];
+    float m1, m2, b1, b2;
+    int16_t range_min, range_max;
+    int16_t min_corr;
+    float   min_mag;
+
+    const int16_t x[4] = { -1800, -1000, 1000, 1800 };
+
+    const bladerf_correction corr_module =
+        i_ch ? BLADERF_CORR_LMS_DCOFF_I : BLADERF_CORR_LMS_DCOFF_Q;
+
+    PR_DBG("Getting coarse estimate for %c\n", i_ch ? 'I' : 'Q');
+
+    for (n = 0; n < 4; n++) {
+        status = tx_cal_measure_correction(state, corr_module, x[n], &mag[n]);
+        if (status != 0) {
+            return status;
+        }
+
+    }
+
+    m1 = (mag[1] - mag[0]) / (x[1] - x[0]);
+    b1 = mag[0] - m1 * x[0];
+
+    m2 = (mag[3] - mag[2]) / (x[3] - x[2]);
+    b2 = mag[2] - m2 * x[2];
+
+    PR_VERBOSE("  m1=%3.8f, b1=%3.8f, m2=%3.8f, b=%3.8f\n", m1, b1, m2, b2);
+
+    if (m1 < 0 && m2 > 0) {
+        const int16_t tmp = (int16_t)((b2 - b1) / (m1 - m2) + 0.5);
+        const int16_t corr_est = (tmp / 16) * 16;
+
+        /* Number of points to sweep on either side of our estimate */
+        const unsigned int n_sweep = 10;
+
+        PR_VERBOSE("  corr_est=%d\n", corr_est);
+
+        range_min = corr_est - 16 * n_sweep;
+        if (range_min < -2048) {
+            range_min = -2048;
+        }
+
+        range_max = corr_est + 16 * n_sweep;
+        if (range_max > 2048) {
+            range_max = 2048;
+        }
+
+    } else {
+        /* The frequency and gain combination have yielded a set of
+         * points that do not form intersecting lines. This may be indicative
+         * of a case where the LMS6 DC bias settings can't pull the DC offset
+         * to a zero-crossing.  We'll just do a slow, full scan to find
+         * a minimum */
+        PR_VERBOSE("  Could not compute estimate. Performing full sweep.\n");
+        range_min = -2048;
+        range_max = 2048;
+    }
+
+
+    PR_DBG("Performing correction value sweep: [%-5d : 16 :%5d]\n",
+           range_min, range_max);
+
+    min_corr = 0;
+    min_mag  = 2048;
+
+    for (n = 0, corr = range_min;
+         corr <= range_max && n < TX_CAL_CORR_SWEEP_LEN;
+         n++, corr += 16) {
+
+        float tmp;
+
+        status = tx_cal_measure_correction(state, corr_module, corr, &tmp);
+        if (status != 0) {
+            return status;
+        }
+
+        if (tmp < 0) {
+            tmp = -tmp;
+        }
+
+        if (tmp < min_mag) {
+            min_corr = corr;
+            min_mag  = tmp;
+        }
+    }
+
+    /* Leave the device set to the minimum */
+    status = bladerf_set_correction(state->dev, BLADERF_MODULE_TX,
+                                    corr_module, min_corr);
+    if (status == 0) {
+        *corr_value  = min_corr;
+        *error_value = min_mag;
+    }
+
+    return status;
+}
+
+static int perform_tx_cal(struct tx_cal *state, struct dc_calibration_params *p)
+{
+    int status = 0;
+
+    status = tx_cal_update_frequency(state, p->frequency);
+    if (status != 0) {
+        return status;
+    }
+
+    state->ts += TX_CAL_TS_INC;
+
+    /* Perform I calibration */
+    status = tx_cal_get_corr(state, true, &p->corr_i, &p->error_i);
+    if (status != 0) {
+        return status;
+    }
+
+    /* Perform Q calibration */
+    status = tx_cal_get_corr(state, false, &p->corr_q, &p->error_q);
+    if (status != 0) {
+        return status;
+    }
+
+    /* Re-do I calibration to try to further fine-tune result */
+    status = tx_cal_get_corr(state, true, &p->corr_i, &p->error_i);
+    if (status != 0) {
+        return status;
+    }
+
+    /* Apply the resulting nominal values */
+    status = set_tx_dc_corr(state->dev, p->corr_i, p->corr_q);
+
+    return status;
+}
+
+int dc_calibration_tx(struct bladerf *dev,
+                      struct dc_calibration_params *params,
+                      size_t num_params, bool print_status)
+{
+    int status = 0;
+    int retval = 0;
+    struct tx_cal_backup backup;
+    struct tx_cal state;
+    size_t i;
+
+    memset(&state, 0, sizeof(state));
+
+    /* Backup the device state prior to making changes */
+    status = get_tx_cal_backup(dev, &backup);
+    if (status != 0) {
+        return status;
+    }
+
+    /* Configure the device for our TX cal operation */
+    status = apply_tx_cal_settings(dev);
+    if (status != 0) {
+        goto out;
+    }
+
+    /* Enable TX and run zero samples through the device */
+    status = tx_cal_tx_init(dev);
+    if (status != 0) {
+        goto out;
+    }
+
+    /* Enable RX */
+    status = tx_cal_rx_init(dev);
+    if (status != 0) {
+        goto out;
+    }
+
+    /* Initialize calibration state information and resources */
+    status = tx_cal_state_init(dev, &state);
+    if (status != 0) {
+        goto out;
+    }
+
+    for (i = 0; i < num_params && status == 0; i++) {
+        status = perform_tx_cal(&state, &params[i]);
+
+        if (status == 0 && print_status) {
+#           ifdef DEBUG_DC_CALIBRATION
+            const char sol = '\n';
+            const char eol = '\n';
+#           else
+            const char sol = '\r';
+            const char eol = '\0';
+#           endif
+            printf("%cCalibrated @ %10" PRIu64 " Hz: "
+                   "I=%4d (Error: %4.2f), "
+                   "Q=%4d (Error: %4.2f)      %c",
+                   sol,
+                   params[i].frequency,
+                   params[i].corr_i, params[i].error_i,
+                   params[i].corr_q, params[i].error_q,
+                   eol);
+            fflush(stdout);
+        }
+    }
+
+    if (print_status) {
+        putchar('\n');
+    }
+
+out:
+    retval = status;
+
+    status = bladerf_enable_module(dev, BLADERF_MODULE_RX, false);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    status = bladerf_enable_module(dev, BLADERF_MODULE_TX, false);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    tx_cal_state_deinit(&state);
+
+    status = set_tx_cal_backup(dev, &backup);
+    if (status != 0 && retval == 0) {
+        retval = status;
+    }
+
+    return retval;
+}
+
+int dc_calibration(struct bladerf *dev, bladerf_module module,
+                   struct dc_calibration_params *params,
+                   size_t num_params, bool show_status)
+{
+    int status;
+
+    switch (module) {
+        case BLADERF_MODULE_RX:
+            status = dc_calibration_rx(dev, params, num_params, show_status);
+            break;
+
+        case BLADERF_MODULE_TX:
+            status = dc_calibration_tx(dev, params, num_params, show_status);
+            break;
+
+        default:
+            status = BLADERF_ERR_INVAL;
+    }
+
+    return status;
+}