uhd/host/lib/usrp/dsp_utils.cpp

//
// 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/usrp/dsp_utils.hpp>
#include <uhd/types/dict.hpp>
#include <uhd/utils/assert.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/math/special_functions/round.hpp>
#include <cmath>

using namespace uhd;
using namespace uhd::usrp;

template <class T> T ceil_log2(T num){
    return std::ceil(std::log(num)/std::log(T(2)));
}

/*!
 *     3                   2                   1                   0
 *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 *  +-------------------------------+-------+-------+-------+-------+
 *  |                                               | DDC0Q | DDC0I |
 *  +-------------------------------+-------+-------+-------+-------+
 */
boost::uint32_t dsp_type1::calc_rx_mux_word(subdev_conn_t subdev_conn){
    switch(subdev_conn){
    case SUBDEV_CONN_COMPLEX_IQ: return (0x1 << 4) | (0x0 << 0); //DDC0Q=ADC0Q, DDC0I=ADC0I
    case SUBDEV_CONN_COMPLEX_QI: return (0x0 << 4) | (0x1 << 0); //DDC0Q=ADC0I, DDC0I=ADC0Q
    case SUBDEV_CONN_REAL_I:     return (0xf << 4) | (0x0 << 0); //DDC0Q=ZERO,  DDC0I=ADC0I
    case SUBDEV_CONN_REAL_Q:     return (0x1 << 4) | (0xf << 0); //DDC0Q=ADC0Q, DDC0I=ZERO
    default:                     UHD_THROW_INVALID_CODE_PATH();
    }
}

/*!
 *     3                   2                   1                   0
 *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 *  +-------------------------------+-------+-------+-------+-------+
 *  |                                               | DAC0Q | DAC0I |
 *  +-------------------------------+-------+-------+-------+-------+
 */
boost::uint32_t dsp_type1::calc_tx_mux_word(subdev_conn_t subdev_conn){
    switch(subdev_conn){
    case SUBDEV_CONN_COMPLEX_IQ: return (0x1 << 4) | (0x0 << 0); //DAC0Q=DUC0Q, DAC0I=DUC0I
    case SUBDEV_CONN_COMPLEX_QI: return (0x0 << 4) | (0x1 << 0); //DAC0Q=DUC0I, DAC0I=DUC0Q
    case SUBDEV_CONN_REAL_I:     return (0xf << 4) | (0x0 << 0); //DAC0Q=ZERO,  DAC0I=DUC0I
    case SUBDEV_CONN_REAL_Q:     return (0x0 << 4) | (0xf << 0); //DAC0Q=DUC0I, DAC0I=ZERO
    default:                     UHD_THROW_INVALID_CODE_PATH();
    }
}

boost::uint32_t dsp_type1::calc_cordic_word_and_update(
    double &freq,
    double codec_rate
){
    UHD_ASSERT_THROW(std::abs(freq) <= codec_rate/2.0);
    static const double scale_factor = std::pow(2.0, 32);

    //calculate the freq register word (signed)
    boost::int32_t freq_word = boost::int32_t(boost::math::round((freq / codec_rate) * scale_factor));

    //update the actual frequency
    freq = (double(freq_word) / scale_factor) * codec_rate;

    return boost::uint32_t(freq_word);
}

boost::uint32_t dsp_type1::calc_cic_filter_word(unsigned rate){
    int hb0 = 0, hb1 = 0;
    if (not (rate & 0x1)){
        hb0 = 1;
        rate /= 2;
    }
    if (not (rate & 0x1)){
        hb1 = 1;
        rate /= 2;
    }
    return (hb1 << 9) | (hb0 << 8) | (rate & 0xff);
}

boost::uint32_t dsp_type1::calc_iq_scale_word(
    boost::int16_t i, boost::int16_t q
){
    return (boost::uint32_t(i) << 16) | (boost::uint32_t(q) << 0);
}

boost::uint32_t dsp_type1::calc_iq_scale_word(unsigned rate){
    // Calculate CIC interpolation (i.e., without halfband interpolators)
    unsigned tmp_rate = calc_cic_filter_word(rate) & 0xff;

    // Calculate closest multiplier constant to reverse gain absent scale multipliers
    double rate_cubed = std::pow(double(tmp_rate), 3);
    boost::int16_t scale = boost::math::iround((4096*std::pow(2, ceil_log2(rate_cubed)))/(1.65*rate_cubed));
    return calc_iq_scale_word(scale, scale);
}

boost::uint32_t dsp_type1::calc_stream_cmd_word(
    const stream_cmd_t &stream_cmd, size_t num_samps_continuous
){
    UHD_ASSERT_THROW(stream_cmd.num_samps <= 0x3fffffff);

    //setup the mode to instruction flags
    typedef boost::tuple<bool, bool, bool> inst_t;
    static const uhd::dict<stream_cmd_t::stream_mode_t, inst_t> mode_to_inst = boost::assign::map_list_of
                                                            //reload, chain, samps
        (stream_cmd_t::STREAM_MODE_START_CONTINUOUS,   inst_t(true,  true,  false))
        (stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS,    inst_t(false, false, false))
        (stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE, inst_t(false, false, true))
        (stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_MORE, inst_t(false, true,  true))
    ;

    //setup the instruction flag values
    bool inst_reload, inst_chain, inst_samps;
    boost::tie(inst_reload, inst_chain, inst_samps) = mode_to_inst[stream_cmd.stream_mode];

    //calculate the word from flags and length
    boost::uint32_t word = 0;
    word |= boost::uint32_t((stream_cmd.stream_now)? 1 : 0) << 31;
    word |= boost::uint32_t((inst_chain)?            1 : 0) << 30;
    word |= boost::uint32_t((inst_reload)?           1 : 0) << 29;
    word |= (inst_samps)? stream_cmd.num_samps : ((inst_chain)? num_samps_continuous : 1);
    return word;
}