uhd: Split radio_control into rf_control interfaces

These rf_control interfaces allow easier implementation of
radio controls as well as allowing easier sharing of code
for implementing e.g. gain_profile.

5 files changed, 657 insertions, 582 deletions

diff --git a/host/include/uhd/rfnoc/CMakeLists.txt b/host/include/uhd/rfnoc/CMakeLists.txt
index 24dfa6645..7b21a02ea 100644
--- a/host/include/uhd/rfnoc/CMakeLists.txt
+++ b/host/include/uhd/rfnoc/CMakeLists.txt
@@ -60,4 +60,4 @@ UHD_INSTALL(FILES
 
 add_subdirectory(blocks)
 add_subdirectory(core)
-
+add_subdirectory(rf_control)
diff --git a/host/include/uhd/rfnoc/radio_control.hpp b/host/include/uhd/rfnoc/radio_control.hpp
index 3e05e1b91..097529147 100644
--- a/host/include/uhd/rfnoc/radio_control.hpp
+++ b/host/include/uhd/rfnoc/radio_control.hpp
@@ -9,6 +9,8 @@
 #include <uhd/config.hpp>
 #include <uhd/features/discoverable_feature_getter_iface.hpp>
 #include <uhd/rfnoc/noc_block_base.hpp>
+#include <uhd/rfnoc/rf_control/core_iface.hpp>
+#include <uhd/rfnoc/rf_control/power_reference_iface.hpp>
 #include <uhd/types/device_addr.hpp>
 #include <uhd/types/direction.hpp>
 #include <uhd/types/eeprom.hpp>
@@ -21,6 +23,8 @@ namespace uhd { namespace rfnoc {
 /*! Parent class for radio block controllers
  */
 class radio_control : public noc_block_base,
+                      public rf_control::core_iface,
+                      public rf_control::power_reference_iface,
                       public virtual ::uhd::features::discoverable_feature_getter_iface
 {
 public:
@@ -47,362 +51,6 @@ public:
     /**************************************************************************
      * RF-Related API Calls
      *************************************************************************/
-    /*! Return the selected TX antenna for channel \p chan.
-     *
-     * \return The selected antenna.
-     */
-    virtual std::string get_tx_antenna(const size_t chan) const = 0;
-
-    /*! Return a list of valid TX antenna for channel \p chan.
-     *
-     * \return The selected antenna.
-     */
-    virtual std::vector<std::string> get_tx_antennas(const size_t chan) const = 0;
-
-    /*! Select RX antenna \p for channel \p chan.
-     *
-     * \throws uhd::value_error if \p ant is not a valid value.
-     */
-    virtual void set_tx_antenna(const std::string& ant, const size_t chan) = 0;
-
-    /*! Return the selected RX antenna for channel \p chan.
-     *
-     * \return The selected antenna.
-     */
-    virtual std::string get_rx_antenna(const size_t chan) const = 0;
-
-    /*! Return a list of valid RX antenna for channel \p chan.
-     *
-     * \return The selected antenna.
-     */
-    virtual std::vector<std::string> get_rx_antennas(const size_t chan) const = 0;
-
-    /*! Select RX antenna \p for channel \p chan.
-     *
-     * \throws uhd::value_error if \p ant is not a valid value.
-     */
-    virtual void set_rx_antenna(const std::string& ant, const size_t chan) = 0;
-
-    /*! Return the current transmit LO frequency on channel \p chan.
-     *
-     * \return The current LO frequency.
-     */
-    virtual double get_tx_frequency(const size_t chan) = 0;
-
-    /*! Tune the TX frequency for channel \p chan.
-     *
-     * This function will attempt to tune as close as possible, and return a
-     * coerced value of the actual tuning result.
-     *
-     * If there is a single LO in this radio, and we're doing direct conversion,
-     * then this is the LO frequency.
-     *
-     * \param freq Frequency in Hz
-     * \param chan Channel to tune
-     *
-     * \return The actual frequency.
-     */
-    virtual double set_tx_frequency(const double freq, size_t chan) = 0;
-
-    /*! Set the TX tune args, if supported by the hardware.
-     */
-    virtual void set_tx_tune_args(const uhd::device_addr_t& args, const size_t chan) = 0;
-
-    /*! Return the range of frequencies that \p chan can be tuned to.
-     *
-     * \return The range of frequencies that we can tune the TX chan to
-     */
-    virtual uhd::freq_range_t get_tx_frequency_range(const size_t chan) const = 0;
-
-    /*! Return the current receive LO frequency on channel \p chan.
-     *
-     * \return The current LO frequency.
-     */
-    virtual double get_rx_frequency(const size_t chan) = 0;
-
-    /*! Tune the RX frequency for channel \p chan.
-     *
-     * This function will attempt to tune as close as possible, and return a
-     * coerced value of the actual tuning result.
-     *
-     * If there is a single LO in this radio, and we're doing direct conversion,
-     * then this is the LO frequency.
-     *
-     * \param freq Requested frequency
-     * \param chan Channel number.
-     * \return The actual frequency.
-     */
-    virtual double set_rx_frequency(const double freq, const size_t chan) = 0;
-
-    /*! Set the TX tune args, if supported by the hardware.
-     */
-    virtual void set_rx_tune_args(const uhd::device_addr_t& args, const size_t chan) = 0;
-
-    /*! Return the range of frequencies that \p chan can be tuned to.
-     *
-     * \return The range of frequencies that we can tune the RX chan to
-     */
-    virtual uhd::freq_range_t get_rx_frequency_range(const size_t chan) const = 0;
-
-    /*! Return a list of valid TX gain names
-     */
-    virtual std::vector<std::string> get_tx_gain_names(const size_t chan) const = 0;
-
-    /*! Return a range of valid TX gains
-     */
-    virtual uhd::gain_range_t get_tx_gain_range(const size_t chan) const = 0;
-
-    /*! Return a range of valid TX gains
-     */
-    virtual uhd::gain_range_t get_tx_gain_range(
-        const std::string& name, const size_t chan) const = 0;
-
-    /*! Return the overall transmit gain on channel \p chan
-     *
-     * \return The actual gain value
-     */
-    virtual double get_tx_gain(const size_t chan) = 0;
-
-    /*! Return the transmit gain \p name on channel \p chan
-     *
-     * \return The actual gain value
-     */
-    virtual double get_tx_gain(const std::string& name, const size_t chan) = 0;
-
-    /*! Set the transmit gain on channel \p chan
-     *
-     * This function will attempt to set the gain as close as possible,
-     * and return a coerced value of the actual gain value.
-     *
-     * This method will set the overall gain. To set a specific gain, use
-     * set_tx_gain(const double, const std::string&, const size_t).
-     *
-     * \return The actual gain value
-     */
-    virtual double set_tx_gain(const double gain, const size_t chan) = 0;
-
-    /*! Set the transmit gain \p name on channel \p chan
-     *
-     * This function will attempt to set the gain as close as possible,
-     * and return a coerced value of the actual gain value.
-     *
-     * \return The actual gain value
-     */
-    virtual double set_tx_gain(
-        const double gain, const std::string& name, const size_t chan) = 0;
-
-    /*! Return true if this channel has a reference power API enabled
-     *
-     * Many devices either don't have a built-in reference power API, or they
-     * require calibration data for it to work. This means that it is not clear,
-     * even when the device type is known, if a device supports setting a power
-     * reference level. Use this method to query the availability of
-     * set_tx_power_reference() and get_tx_power_reference(), which will throw
-     * a uhd::not_implemented_error or uhd::runtime_error if they cannot be used.
-     *
-     * See \ref page_power for more information, or query the specific device's
-     * manual page to see if a power API is available, and how to enable it.
-     *
-     * \param chan The channel for which this feature is queried
-     *
-     * \returns true if this channel has a TX power API available
-     */
-    virtual bool has_tx_power_reference(const size_t chan) = 0;
-
-    /*! Set the reference TX power level for a given channel
-     *
-     * Note: This functionality is not supported for most devices, and will
-     * cause a uhd::not_implemented_error exception to be thrown on devices that
-     * do not have this functionality.
-     *
-     * For more information on how to use this API, see \ref page_power.
-     *
-     * \param power_dbm The reference power level in dBm
-     * \param chan The channel for which this setting applies
-     *
-     * \throws uhd::not_implemented_error if this functionality does not exist
-     *         for this device
-     */
-    virtual void set_tx_power_reference(
-        const double power_dbm, const size_t chan) = 0;
-
-    /*! Return the actual reference TX power level.
-     *
-     * Note: This functionality is not supported for most devices, and will
-     * cause a uhd::not_implemented_error exception to be thrown on devices that
-     * do not have this functionality.
-     *
-     * For more information on how to use this API, see \ref page_power.
-     *
-     * \param chan The channel for which this setting is queried
-     * \throws uhd::not_implemented_error if this functionality does not exist
-     *         for this device
-     */
-    virtual double get_tx_power_reference(const size_t chan) = 0;
-
-    /*! Return the keys by which the power calibration data is referenced for this
-     * channel.
-     *
-     * The first entry is the key, the second the serial. These are the same
-     * arguments that can be used for uhd::usrp::cal::database::read_cal_data()
-     * and friends. See also \ref cal_db_serial.
-     *
-     * Note that the key can change at runtime, e.g., when the antenna port is
-     * switched.
-     *
-     * The difference between this and has_tx_power_reference() is that the
-     * latter requires both device support as well as calibration data, whereas
-     * this function will never throw, and will always return a non-empty vector
-     * if device support is there, even if the device does not have calbration
-     * data loaded.
-     *
-     * \returns an empty vector if no power calibration is supported, or a
-     *          vector of length 2 with key and serial if it does.
-     */
-    virtual std::vector<std::string> get_tx_power_ref_keys(const size_t chan = 0) = 0;
-
-    /*! Return the available TX power range given the current configuration
-     *
-     * This will return the range of available power levels given the current
-     * frequency, gain profile, antenna, and whatever other settings may affect
-     * the available power ranges. Note that the available power range may
-     * change frequently, so don't assume an immutable range.
-     *
-     * \param chan The channel index
-     */
-    virtual meta_range_t get_tx_power_range(const size_t chan) = 0;
-
-    /*! Return a list of valid RX gain names
-     */
-    virtual std::vector<std::string> get_rx_gain_names(const size_t chan) const = 0;
-
-    /*! Return a range of valid RX gains
-     */
-    virtual uhd::gain_range_t get_rx_gain_range(const size_t chan) const = 0;
-
-    /*! Return a range of valid RX gains
-     */
-    virtual uhd::gain_range_t get_rx_gain_range(
-        const std::string& name, const size_t chan) const = 0;
-
-    /*! Return the overall receive gain on channel \p chan
-     *
-     * \return The actual gain value
-     */
-    virtual double get_rx_gain(const size_t chan) = 0;
-
-    /*! Return the receive gain \p name on channel \p chan
-     *
-     * \return The actual gain value
-     */
-    virtual double get_rx_gain(const std::string& name, const size_t chan) = 0;
-
-    /*! Set the overall receive gain on channel \p chan
-     *
-     * This function will attempt to set the gain as close as possible,
-     * and return a coerced value of the actual gain value.
-     *
-     * \return The actual gain value
-     */
-    virtual double set_rx_gain(const double gain, const size_t chan) = 0;
-
-    /*! Set the receive gain \p on channel \p chan
-     *
-     * This function will attempt to set the gain as close as possible,
-     * and return a coerced value of the actual gain value.
-     *
-     * \return The actual gain value
-     */
-    virtual double set_rx_gain(
-        const double gain, const std::string& name, const size_t chan) = 0;
-
-    /*! Enable RX AGC on this radio
-     *
-     * \throws uhd::not_implemented_error if this radio doesn't support RX AGC
-     */
-    virtual void set_rx_agc(const bool enable, const size_t chan) = 0;
-
-    /*! Return true if this channel has a reference power API enabled
-     *
-     * Many devices either don't have a built-in reference power API, or they
-     * require calibration data for it to work. This means that it is not clear,
-     * even when the device type is known, if a device supports setting a power
-     * reference level. Use this method to query the availability of
-     * set_rx_power_reference() and get_rx_power_reference(), which will throw
-     * a uhd::not_implemented_error or uhd::runtime_error if they cannot be used.
-     *
-     * See \ref page_power for more information, or query the specific device's
-     * manual page to see if a power API is available, and how to enable it.
-     *
-     * \param chan The channel for which this feature is queried
-     *
-     * \returns true if this channel has an RX power API available
-     */
-    virtual bool has_rx_power_reference(const size_t chan) = 0;
-
-    /*! Set the reference RX power level for a given channel
-     *
-     * Note: This functionality is not supported for most devices, and will
-     * cause a uhd::not_implemented_error exception to be thrown on devices that
-     * do not have this functionality.
-     *
-     * For more information on how to use this API, see \ref page_power.
-     *
-     * \param power_dbm The reference power level in dBm
-     * \param chan The channel for which this setting applies
-     *
-     * \throws uhd::not_implemented_error if this functionality does not exist
-     *         for this device
-     */
-    virtual void set_rx_power_reference(
-        const double power_dbm, const size_t chan) = 0;
-
-    /*! Return the actual reference RX power level.
-     *
-     * Note: This functionality is not supported for most devices, and will
-     * cause a uhd::not_implemented_error exception to be thrown on devices that
-     * do not have this functionality.
-     *
-     * For more information on how to use this API, see \ref page_power.
-     *
-     * \param chan The channel for which this setting is queried
-     * \throws uhd::not_implemented_error if this functionality does not exist
-     *         for this device
-     */
-    virtual double get_rx_power_reference(const size_t chan) = 0;
-
-    /*! Return the keys by which the power calibration data is referenced for this
-     * channel.
-     *
-     * The first entry is the key, the second the serial. These are the same
-     * arguments that can be used for uhd::usrp::cal::database::read_cal_data()
-     * and friends. See also \ref cal_db_serial.
-     *
-     * Note that the key can change at runtime, e.g., when the antenna port is
-     * switched.
-     *
-     * The difference between this and has_rx_power_reference() is that the
-     * latter requires both device support as well as calibration data, whereas
-     * this function will never throw, and will always return a non-empty vector
-     * if device support is there, even if the device does not have calbration
-     * data loaded.
-     *
-     * \returns an empty vector if no power calibration is supported, or a
-     *          vector of length 2 with key and serial if it does.
-     */
-    virtual std::vector<std::string> get_rx_power_ref_keys(const size_t chan = 0) = 0;
-
-    /*! Return the available RX power range given the current configuration
-     *
-     * This will return the range of available power levels given the current
-     * frequency, gain profile, antenna, and whatever other settings may affect
-     * the available power ranges. Note that the available power range may
-     * change frequently, so don't assume an immutable range.
-     *
-     * \param chan The channel index
-     */
-    virtual meta_range_t get_rx_power_range(const size_t chan) = 0;
-
     /*! Return a list of TX gain profiles for this radio
      */
     virtual std::vector<std::string> get_tx_gain_profile_names(
@@ -429,231 +77,6 @@ public:
      */
     virtual std::string get_rx_gain_profile(const size_t chan) const = 0;
 
-    /*! Return a range of valid TX bandwidths
-     */
-    virtual meta_range_t get_tx_bandwidth_range(size_t chan) const = 0;
-
-    /*! Return the analog filter bandwidth channel \p chan
-     *
-     * \return The actual bandwidth value
-     */
-    virtual double get_tx_bandwidth(const size_t chan) = 0;
-
-    /*! Set the analog filter bandwidth channel \p chan
-     *
-     * This function will attempt to set the analog bandwidth.
-     *
-     * \return The actual bandwidth value
-     */
-    virtual double set_tx_bandwidth(const double bandwidth, const size_t chan) = 0;
-
-    /*! Return a range of valid RX bandwidths
-     */
-    virtual meta_range_t get_rx_bandwidth_range(size_t chan) const = 0;
-
-    /*! Return the analog filter bandwidth channel \p chan
-     *
-     * \return The actual bandwidth value
-     */
-    virtual double get_rx_bandwidth(const size_t chan) = 0;
-
-    /*! Set the analog filter bandwidth channel \p chan
-     *
-     * This function will attempt to set the analog bandwidth.
-     *
-     * \return The actual bandwidth value
-     */
-    virtual double set_rx_bandwidth(const double bandwidth, const size_t chan) = 0;
-
-    /**************************************************************************
-     * LO Controls
-     *************************************************************************/
-    /*! Get a list of possible LO stage names
-     *
-     * \param chan the channel index 0 to N-1
-     * \return a vector of strings for possible LO names
-     */
-    virtual std::vector<std::string> get_rx_lo_names(const size_t chan) const = 0;
-
-    /*! Get a list of possible LO sources.
-     *
-     * Channels which do not have controllable LO sources
-     * will return "internal".
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     * \return a vector of strings for possible settings
-     */
-    virtual std::vector<std::string> get_rx_lo_sources(
-        const std::string& name, const size_t chan) const = 0;
-
-    /*!
-     * Get the LO frequency range of the RX LO.
-     * If the channel does not have independently configurable LOs
-     * the rf frequency range will be returned.
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     * \return a frequency range object
-     */
-    virtual freq_range_t get_rx_lo_freq_range(
-        const std::string& name, const size_t chan) const = 0;
-
-    /*!
-     * Set the LO source for a channel.
-     * For usrps that support selectable LOs, this function
-     * allows switching between them.
-     * Typical options for source: internal, external.
-     * \param src a string representing the LO source
-     * \param name the name of the LO stage to update
-     * \param chan the channel index 0 to N-1
-     */
-    virtual void set_rx_lo_source(
-        const std::string& src, const std::string& name, const size_t chan) = 0;
-
-    /*!
-     * Get the currently set LO source.
-     * Channels without controllable LO sources will return
-     * "internal"
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     * \return the configured LO source
-     */
-    virtual const std::string get_rx_lo_source(
-        const std::string& name, const size_t chan) = 0;
-
-    /*!
-     * Set whether the LO used by the usrp device is exported
-     * For usrps that support exportable LOs, this function
-     * configures if the LO used by chan is exported or not.
-     * \param enabled if true then export the LO
-     * \param name the name of the LO stage to update
-     * \param chan the channel index 0 to N-1 for the source channel
-     */
-    virtual void set_rx_lo_export_enabled(
-        bool enabled, const std::string& name, const size_t chan) = 0;
-
-    /*!
-     * Returns true if the currently selected LO is being exported.
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     */
-    virtual bool get_rx_lo_export_enabled(
-        const std::string& name, const size_t chan) const = 0;
-
-    /*!
-     * Set the RX LO frequency (Advanced).
-     * \param freq the frequency to set the LO to
-     * \param name the name of the LO stage to update
-     * \param chan the channel index 0 to N-1
-     * \return a coerced LO frequency
-     */
-    virtual double set_rx_lo_freq(
-        double freq, const std::string& name, const size_t chan) = 0;
-
-    /*!
-     * Get the current RX LO frequency (Advanced).
-     * If the channel does not have independently configurable LOs
-     * the current rf frequency will be returned.
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     * \return the configured LO frequency
-     */
-    virtual double get_rx_lo_freq(const std::string& name, const size_t chan) = 0;
-
-    /*! Get a list of possible LO stage names
-     *
-     * \param chan the channel index 0 to N-1
-     * \return a vector of strings for possible LO names
-     */
-    virtual std::vector<std::string> get_tx_lo_names(const size_t chan) const = 0;
-
-    /*! Get a list of possible LO sources.
-     *
-     * Channels which do not have controllable LO sources
-     * will return "internal".
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     * \return a vector of strings for possible settings
-     */
-    virtual std::vector<std::string> get_tx_lo_sources(
-        const std::string& name, const size_t chan) = 0;
-
-    /*!
-     * Get the LO frequency range of the tx LO.
-     * If the channel does not have independently configurable LOs
-     * the rf frequency range will be returned.
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     * \return a frequency range object
-     */
-    virtual freq_range_t get_tx_lo_freq_range(
-        const std::string& name, const size_t chan) = 0;
-
-    /*!
-     * Set the LO source for a channel.
-     * For usrps that support selectable LOs, this function
-     * allows switching between them.
-     * Typical options for source: internal, external.
-     * \param src a string representing the LO source
-     * \param name the name of the LO stage to update
-     * \param chan the channel index 0 to N-1
-     */
-    virtual void set_tx_lo_source(
-        const std::string& src, const std::string& name, const size_t chan) = 0;
-
-    /*!
-     * Get the currently set LO source.
-     * Channels without controllable LO sources will return
-     * "internal"
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     * \return the configured LO source
-     */
-    virtual const std::string get_tx_lo_source(
-        const std::string& name, const size_t chan) = 0;
-
-    /*!
-     * Set whether the LO used by the usrp device is exported
-     * For usrps that support exportable LOs, this function
-     * configures if the LO used by chan is exported or not.
-     * \param enabled if true then export the LO
-     * \param name the name of the LO stage to update
-     * \param chan the channel index 0 to N-1 for the source channel
-     */
-    virtual void set_tx_lo_export_enabled(
-        const bool enabled, const std::string& name, const size_t chan) = 0;
-
-    /*!
-     * Returns true if the currently selected LO is being exported.
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     */
-    virtual bool get_tx_lo_export_enabled(const std::string& name, const size_t chan) = 0;
-
-    /*!  Set the tx LO frequency (Advanced).
-     *
-     * See also multi_usrp::set_tx_lo_freq().
-     *
-     * \param freq the frequency to set the LO to
-     * \param name the name of the LO stage to update
-     * \param chan the channel index 0 to N-1
-     * \return a coerced LO frequency
-     */
-    virtual double set_tx_lo_freq(
-        const double freq, const std::string& name, const size_t chan) = 0;
-
-    /*!  Get the current TX LO frequency (Advanced).
-     *
-     * See also multi_usrp::get_tx_lo_freq()
-     *
-     * If the channel does not have independently configurable LOs
-     * the current RF frequency will be returned.
-     *
-     * \param name the name of the LO stage to query
-     * \param chan the channel index 0 to N-1
-     * \return the configured LO frequency
-     */
-    virtual double get_tx_lo_freq(const std::string& name, const size_t chan) = 0;
-
     /**************************************************************************
      * Calibration-Related API Calls
      *************************************************************************/
diff --git a/host/include/uhd/rfnoc/rf_control/CMakeLists.txt b/host/include/uhd/rfnoc/rf_control/CMakeLists.txt
new file mode 100644
index 000000000..02009ebd6
--- /dev/null
+++ b/host/include/uhd/rfnoc/rf_control/CMakeLists.txt
@@ -0,0 +1,13 @@
+#
+# Copyright 2020 Ettus Research, a National Instruments Brand
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+UHD_INSTALL(FILES
+    core_iface.hpp
+    power_reference_iface.hpp
+
+    DESTINATION ${INCLUDE_DIR}/uhd/rfnoc/rf_control
+    COMPONENT headers
+)
diff --git a/host/include/uhd/rfnoc/rf_control/core_iface.hpp b/host/include/uhd/rfnoc/rf_control/core_iface.hpp
new file mode 100644
index 000000000..9b780b3c8
--- /dev/null
+++ b/host/include/uhd/rfnoc/rf_control/core_iface.hpp
@@ -0,0 +1,448 @@
+//
+// Copyright 2020 Ettus Research, a National Instruments Brand
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#pragma once
+
+#include <uhd/types/ranges.hpp>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace uhd { namespace rfnoc { namespace rf_control {
+
+/*! Interface for generic RF control functions
+ *
+ * This interface contains all methods related directly to RF control which
+ * aren't contained in a different rf_control class. These methods are not
+ * usually accessed via this interface, but are usually accessed via an
+ * instance of radio_control, which implements this class.
+ */
+class core_iface
+{
+public:
+    virtual ~core_iface() = default;
+
+    /*! Return the selected TX antenna for channel \p chan.
+     *
+     * \return The selected antenna.
+     */
+    virtual std::string get_tx_antenna(const size_t chan) const = 0;
+
+    /*! Return a list of valid TX antenna for channel \p chan.
+     *
+     * \return The selected antenna.
+     */
+    virtual std::vector<std::string> get_tx_antennas(const size_t chan) const = 0;
+
+    /*! Select RX antenna \p for channel \p chan.
+     *
+     * \throws uhd::value_error if \p ant is not a valid value.
+     */
+    virtual void set_tx_antenna(const std::string& ant, const size_t chan) = 0;
+
+    /*! Return the selected RX antenna for channel \p chan.
+     *
+     * \return The selected antenna.
+     */
+    virtual std::string get_rx_antenna(const size_t chan) const = 0;
+
+    /*! Return a list of valid RX antenna for channel \p chan.
+     *
+     * \return The selected antenna.
+     */
+    virtual std::vector<std::string> get_rx_antennas(const size_t chan) const = 0;
+
+    /*! Select RX antenna \p for channel \p chan.
+     *
+     * \throws uhd::value_error if \p ant is not a valid value.
+     */
+    virtual void set_rx_antenna(const std::string& ant, const size_t chan) = 0;
+
+    /*! Return the current transmit LO frequency on channel \p chan.
+     *
+     * \return The current LO frequency.
+     */
+    virtual double get_tx_frequency(const size_t chan) = 0;
+
+    /*! Tune the TX frequency for channel \p chan.
+     *
+     * This function will attempt to tune as close as possible, and return a
+     * coerced value of the actual tuning result.
+     *
+     * If there is a single LO in this radio, and we're doing direct conversion,
+     * then this is the LO frequency.
+     *
+     * \param freq Frequency in Hz
+     * \param chan Channel to tune
+     *
+     * \return The actual frequency.
+     */
+    virtual double set_tx_frequency(const double freq, size_t chan) = 0;
+
+    /*! Set the TX tune args, if supported by the hardware.
+     */
+    virtual void set_tx_tune_args(const uhd::device_addr_t& args, const size_t chan) = 0;
+
+    /*! Return the range of frequencies that \p chan can be tuned to.
+     *
+     * \return The range of frequencies that we can tune the TX chan to
+     */
+    virtual uhd::freq_range_t get_tx_frequency_range(const size_t chan) const = 0;
+
+    /*! Return the current receive LO frequency on channel \p chan.
+     *
+     * \return The current LO frequency.
+     */
+    virtual double get_rx_frequency(const size_t chan) = 0;
+
+    /*! Tune the RX frequency for channel \p chan.
+     *
+     * This function will attempt to tune as close as possible, and return a
+     * coerced value of the actual tuning result.
+     *
+     * If there is a single LO in this radio, and we're doing direct conversion,
+     * then this is the LO frequency.
+     *
+     * \param freq Requested frequency
+     * \param chan Channel number.
+     * \return The actual frequency.
+     */
+    virtual double set_rx_frequency(const double freq, const size_t chan) = 0;
+
+    /*! Set the TX tune args, if supported by the hardware.
+     */
+    virtual void set_rx_tune_args(const uhd::device_addr_t& args, const size_t chan) = 0;
+
+    /*! Return the range of frequencies that \p chan can be tuned to.
+     *
+     * \return The range of frequencies that we can tune the RX chan to
+     */
+    virtual uhd::freq_range_t get_rx_frequency_range(const size_t chan) const = 0;
+
+    /*! Return a list of valid TX gain names
+     */
+    virtual std::vector<std::string> get_tx_gain_names(const size_t chan) const = 0;
+
+    /*! Return a range of valid TX gains
+     */
+    virtual uhd::gain_range_t get_tx_gain_range(const size_t chan) const = 0;
+
+    /*! Return a range of valid TX gains
+     */
+    virtual uhd::gain_range_t get_tx_gain_range(
+        const std::string& name, const size_t chan) const = 0;
+
+    /*! Return the overall transmit gain on channel \p chan
+     *
+     * \return The actual gain value
+     */
+    virtual double get_tx_gain(const size_t chan) = 0;
+
+    /*! Return the transmit gain \p name on channel \p chan
+     *
+     * \return The actual gain value
+     */
+    virtual double get_tx_gain(const std::string& name, const size_t chan) = 0;
+
+    /*! Set the transmit gain on channel \p chan
+     *
+     * This function will attempt to set the gain as close as possible,
+     * and return a coerced value of the actual gain value.
+     *
+     * This method will set the overall gain. To set a specific gain, use
+     * set_tx_gain(const double, const std::string&, const size_t).
+     *
+     * \return The actual gain value
+     */
+    virtual double set_tx_gain(const double gain, const size_t chan) = 0;
+
+    /*! Set the transmit gain \p name on channel \p chan
+     *
+     * This function will attempt to set the gain as close as possible,
+     * and return a coerced value of the actual gain value.
+     *
+     * \return The actual gain value
+     */
+    virtual double set_tx_gain(
+        const double gain, const std::string& name, const size_t chan) = 0;
+
+    /*! Return a list of valid RX gain names
+     */
+    virtual std::vector<std::string> get_rx_gain_names(const size_t chan) const = 0;
+
+    /*! Return a range of valid RX gains
+     */
+    virtual uhd::gain_range_t get_rx_gain_range(const size_t chan) const = 0;
+
+    /*! Return a range of valid RX gains
+     */
+    virtual uhd::gain_range_t get_rx_gain_range(
+        const std::string& name, const size_t chan) const = 0;
+
+    /*! Return the overall receive gain on channel \p chan
+     *
+     * \return The actual gain value
+     */
+    virtual double get_rx_gain(const size_t chan) = 0;
+
+    /*! Return the receive gain \p name on channel \p chan
+     *
+     * \return The actual gain value
+     */
+    virtual double get_rx_gain(const std::string& name, const size_t chan) = 0;
+
+    /*! Set the overall receive gain on channel \p chan
+     *
+     * This function will attempt to set the gain as close as possible,
+     * and return a coerced value of the actual gain value.
+     *
+     * \return The actual gain value
+     */
+    virtual double set_rx_gain(const double gain, const size_t chan) = 0;
+
+    /*! Set the receive gain \p on channel \p chan
+     *
+     * This function will attempt to set the gain as close as possible,
+     * and return a coerced value of the actual gain value.
+     *
+     * \return The actual gain value
+     */
+    virtual double set_rx_gain(
+        const double gain, const std::string& name, const size_t chan) = 0;
+
+    /*! Enable RX AGC on this radio
+     *
+     * \throws uhd::not_implemented_error if this radio doesn't support RX AGC
+     */
+    virtual void set_rx_agc(const bool enable, const size_t chan) = 0;
+
+    /*! Return a range of valid TX bandwidths
+     */
+    virtual meta_range_t get_tx_bandwidth_range(size_t chan) const = 0;
+
+    /*! Return the analog filter bandwidth channel \p chan
+     *
+     * \return The actual bandwidth value
+     */
+    virtual double get_tx_bandwidth(const size_t chan) = 0;
+
+    /*! Set the analog filter bandwidth channel \p chan
+     *
+     * This function will attempt to set the analog bandwidth.
+     *
+     * \return The actual bandwidth value
+     */
+    virtual double set_tx_bandwidth(const double bandwidth, const size_t chan) = 0;
+
+    /*! Return a range of valid RX bandwidths
+     */
+    virtual meta_range_t get_rx_bandwidth_range(size_t chan) const = 0;
+
+    /*! Return the analog filter bandwidth channel \p chan
+     *
+     * \return The actual bandwidth value
+     */
+    virtual double get_rx_bandwidth(const size_t chan) = 0;
+
+    /*! Set the analog filter bandwidth channel \p chan
+     *
+     * This function will attempt to set the analog bandwidth.
+     *
+     * \return The actual bandwidth value
+     */
+    virtual double set_rx_bandwidth(const double bandwidth, const size_t chan) = 0;
+
+    /**************************************************************************
+     * LO Controls
+     *************************************************************************/
+    /*! Get a list of possible LO stage names
+     *
+     * \param chan the channel index 0 to N-1
+     * \return a vector of strings for possible LO names
+     */
+    virtual std::vector<std::string> get_rx_lo_names(const size_t chan) const = 0;
+
+    /*! Get a list of possible LO sources.
+     *
+     * Channels which do not have controllable LO sources
+     * will return "internal".
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     * \return a vector of strings for possible settings
+     */
+    virtual std::vector<std::string> get_rx_lo_sources(
+        const std::string& name, const size_t chan) const = 0;
+
+    /*!
+     * Get the LO frequency range of the RX LO.
+     * If the channel does not have independently configurable LOs
+     * the rf frequency range will be returned.
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     * \return a frequency range object
+     */
+    virtual freq_range_t get_rx_lo_freq_range(
+        const std::string& name, const size_t chan) const = 0;
+
+    /*!
+     * Set the LO source for a channel.
+     * For usrps that support selectable LOs, this function
+     * allows switching between them.
+     * Typical options for source: internal, external.
+     * \param src a string representing the LO source
+     * \param name the name of the LO stage to update
+     * \param chan the channel index 0 to N-1
+     */
+    virtual void set_rx_lo_source(
+        const std::string& src, const std::string& name, const size_t chan) = 0;
+
+    /*!
+     * Get the currently set LO source.
+     * Channels without controllable LO sources will return
+     * "internal"
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     * \return the configured LO source
+     */
+    virtual const std::string get_rx_lo_source(
+        const std::string& name, const size_t chan) = 0;
+
+    /*!
+     * Set whether the LO used by the usrp device is exported
+     * For usrps that support exportable LOs, this function
+     * configures if the LO used by chan is exported or not.
+     * \param enabled if true then export the LO
+     * \param name the name of the LO stage to update
+     * \param chan the channel index 0 to N-1 for the source channel
+     */
+    virtual void set_rx_lo_export_enabled(
+        bool enabled, const std::string& name, const size_t chan) = 0;
+
+    /*!
+     * Returns true if the currently selected LO is being exported.
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     */
+    virtual bool get_rx_lo_export_enabled(
+        const std::string& name, const size_t chan) const = 0;
+
+    /*!
+     * Set the RX LO frequency (Advanced).
+     * \param freq the frequency to set the LO to
+     * \param name the name of the LO stage to update
+     * \param chan the channel index 0 to N-1
+     * \return a coerced LO frequency
+     */
+    virtual double set_rx_lo_freq(
+        double freq, const std::string& name, const size_t chan) = 0;
+
+    /*!
+     * Get the current RX LO frequency (Advanced).
+     * If the channel does not have independently configurable LOs
+     * the current rf frequency will be returned.
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     * \return the configured LO frequency
+     */
+    virtual double get_rx_lo_freq(const std::string& name, const size_t chan) = 0;
+
+    /*! Get a list of possible LO stage names
+     *
+     * \param chan the channel index 0 to N-1
+     * \return a vector of strings for possible LO names
+     */
+    virtual std::vector<std::string> get_tx_lo_names(const size_t chan) const = 0;
+
+    /*! Get a list of possible LO sources.
+     *
+     * Channels which do not have controllable LO sources
+     * will return "internal".
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     * \return a vector of strings for possible settings
+     */
+    virtual std::vector<std::string> get_tx_lo_sources(
+        const std::string& name, const size_t chan) = 0;
+
+    /*!
+     * Get the LO frequency range of the tx LO.
+     * If the channel does not have independently configurable LOs
+     * the rf frequency range will be returned.
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     * \return a frequency range object
+     */
+    virtual freq_range_t get_tx_lo_freq_range(
+        const std::string& name, const size_t chan) = 0;
+
+    /*!
+     * Set the LO source for a channel.
+     * For usrps that support selectable LOs, this function
+     * allows switching between them.
+     * Typical options for source: internal, external.
+     * \param src a string representing the LO source
+     * \param name the name of the LO stage to update
+     * \param chan the channel index 0 to N-1
+     */
+    virtual void set_tx_lo_source(
+        const std::string& src, const std::string& name, const size_t chan) = 0;
+
+    /*!
+     * Get the currently set LO source.
+     * Channels without controllable LO sources will return
+     * "internal"
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     * \return the configured LO source
+     */
+    virtual const std::string get_tx_lo_source(
+        const std::string& name, const size_t chan) = 0;
+
+    /*!
+     * Set whether the LO used by the usrp device is exported
+     * For usrps that support exportable LOs, this function
+     * configures if the LO used by chan is exported or not.
+     * \param enabled if true then export the LO
+     * \param name the name of the LO stage to update
+     * \param chan the channel index 0 to N-1 for the source channel
+     */
+    virtual void set_tx_lo_export_enabled(
+        const bool enabled, const std::string& name, const size_t chan) = 0;
+
+    /*!
+     * Returns true if the currently selected LO is being exported.
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     */
+    virtual bool get_tx_lo_export_enabled(const std::string& name, const size_t chan) = 0;
+
+    /*!  Set the tx LO frequency (Advanced).
+     *
+     * See also multi_usrp::set_tx_lo_freq().
+     *
+     * \param freq the frequency to set the LO to
+     * \param name the name of the LO stage to update
+     * \param chan the channel index 0 to N-1
+     * \return a coerced LO frequency
+     */
+    virtual double set_tx_lo_freq(
+        const double freq, const std::string& name, const size_t chan) = 0;
+
+    /*!  Get the current TX LO frequency (Advanced).
+     *
+     * See also multi_usrp::get_tx_lo_freq()
+     *
+     * If the channel does not have independently configurable LOs
+     * the current RF frequency will be returned.
+     *
+     * \param name the name of the LO stage to query
+     * \param chan the channel index 0 to N-1
+     * \return the configured LO frequency
+     */
+    virtual double get_tx_lo_freq(const std::string& name, const size_t chan) = 0;
+};
+
+}}} // namespace uhd::rfnoc::rf_control
diff --git a/host/include/uhd/rfnoc/rf_control/power_reference_iface.hpp b/host/include/uhd/rfnoc/rf_control/power_reference_iface.hpp
new file mode 100644
index 000000000..84f0a1805
--- /dev/null
+++ b/host/include/uhd/rfnoc/rf_control/power_reference_iface.hpp
@@ -0,0 +1,191 @@
+//
+// Copyright 2020 Ettus Research, a National Instruments Brand
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#pragma once
+
+#include <uhd/types/direction.hpp>
+#include <uhd/types/ranges.hpp>
+#include <uhd/utils/assert_has.hpp>
+#include <string>
+#include <vector>
+
+namespace uhd { namespace rfnoc { namespace rf_control {
+
+/*! Interface for reference power API commands
+ *
+ * This interface contains all methods related to the reference power API,
+ * and is usually only accessed directly via the radio_control class.
+ */
+class power_reference_iface
+{
+public:
+    virtual ~power_reference_iface() = default;
+
+    /*! Return true if this channel has a reference power API enabled
+     *
+     * Many devices either don't have a built-in reference power API, or they
+     * require calibration data for it to work. This means that it is not clear,
+     * even when the device type is known, if a device supports setting a power
+     * reference level. Use this method to query the availability of
+     * set_rx_power_reference() and get_rx_power_reference(), which will throw
+     * a uhd::not_implemented_error or uhd::runtime_error if they cannot be used.
+     *
+     * See \ref page_power for more information, or query the specific device's
+     * manual page to see if a power API is available, and how to enable it.
+     *
+     * \param chan The channel for which this feature is queried
+     *
+     * \returns true if this channel has an RX power API available
+     */
+    virtual bool has_rx_power_reference(const size_t chan = 0) = 0;
+
+    /*! Set the reference RX power level for a given channel
+     *
+     * Note: This functionality is not supported for most devices, and will
+     * cause a uhd::not_implemented_error exception to be thrown on devices that
+     * do not have this functionality.
+     *
+     * For more information on how to use this API, see \ref page_power.
+     *
+     * \param power_dbm The reference power level in dBm
+     * \param chan The channel for which this setting applies
+     *
+     * \throws uhd::not_implemented_error if this functionality does not exist
+     *         for this device
+     */
+    virtual void set_rx_power_reference(
+        const double power_dbm, const size_t chan = 0) = 0;
+
+    /*! Return the actual reference RX power level.
+     *
+     * Note: This functionality is not supported for most devices, and will
+     * cause a uhd::not_implemented_error exception to be thrown on devices that
+     * do not have this functionality.
+     *
+     * For more information on how to use this API, see \ref page_power.
+     *
+     * \param chan The channel for which this setting is queried
+     * \throws uhd::not_implemented_error if this functionality does not exist
+     *         for this device
+     */
+    virtual double get_rx_power_reference(const size_t chan = 0) = 0;
+
+    /*! Return the keys by which the power calibration data is referenced for this
+     * channel.
+     *
+     * The first entry is the key, the second the serial. These are the same
+     * arguments that can be used for uhd::usrp::cal::database::read_cal_data()
+     * and friends. See also \ref cal_db_serial.
+     *
+     * Note that the key can change at runtime, e.g., when the antenna port is
+     * switched.
+     *
+     * The difference between this and has_rx_power_reference() is that the
+     * latter requires both device support as well as calibration data, whereas
+     * this function will never throw, and will always return a non-empty vector
+     * if device support is there, even if the device does not have calbration
+     * data loaded.
+     *
+     * \returns an empty vector if no power calibration is supported, or a
+     *          vector of length 2 with key and serial if it does.
+     */
+    virtual std::vector<std::string> get_rx_power_ref_keys(const size_t chan = 0) = 0;
+
+    /*! Return the available RX power range given the current configuration
+     *
+     * This will return the range of available power levels given the current
+     * frequency, gain profile, antenna, and whatever other settings may affect
+     * the available power ranges. Note that the available power range may
+     * change frequently, so don't assume an immutable range.
+     *
+     * \param chan The channel index
+     */
+    virtual meta_range_t get_rx_power_range(const size_t chan) = 0;
+
+    /*! Return true if this channel has a reference power API enabled
+     *
+     * Many devices either don't have a built-in reference power API, or they
+     * require calibration data for it to work. This means that it is not clear,
+     * even when the device type is known, if a device supports setting a power
+     * reference level. Use this method to query the availability of
+     * set_tx_power_reference() and get_tx_power_reference(), which will throw
+     * a uhd::not_implemented_error or uhd::runtime_error if they cannot be used.
+     *
+     * See \ref page_power for more information, or query the specific device's
+     * manual page to see if a power API is available, and how to enable it.
+     *
+     * \param chan The channel for which this feature is queried
+     *
+     * \returns true if this channel has a TX power API available
+     */
+    virtual bool has_tx_power_reference(const size_t chan = 0) = 0;
+
+    /*! Set the reference TX power level for a given channel
+     *
+     * Note: This functionality is not supported for most devices, and will
+     * cause a uhd::not_implemented_error exception to be thrown on devices that
+     * do not have this functionality.
+     *
+     * For more information on how to use this API, see \ref page_power.
+     *
+     * \param power_dbm The reference power level in dBm
+     * \param chan The channel for which this setting applies
+     *
+     * \throws uhd::not_implemented_error if this functionality does not exist
+     *         for this device
+     */
+    virtual void set_tx_power_reference(
+        const double power_dbm, const size_t chan = 0) = 0;
+
+    /*! Return the actual reference TX power level.
+     *
+     * Note: This functionality is not supported for most devices, and will
+     * cause a uhd::not_implemented_error exception to be thrown on devices that
+     * do not have this functionality.
+     *
+     * For more information on how to use this API, see \ref page_power.
+     *
+     * \param chan The channel for which this setting is queried
+     * \throws uhd::not_implemented_error if this functionality does not exist
+     *         for this device
+     */
+    virtual double get_tx_power_reference(const size_t chan = 0) = 0;
+
+    /*! Return the keys by which the power calibration data is referenced for this
+     * channel.
+     *
+     * The first entry is the key, the second the serial. These are the same
+     * arguments that can be used for uhd::usrp::cal::database::read_cal_data()
+     * and friends. See also \ref cal_db_serial.
+     *
+     * Note that the key can change at runtime, e.g., when the antenna port is
+     * switched.
+     *
+     * The difference between this and has_tx_power_reference() is that the
+     * latter requires both device support as well as calibration data, whereas
+     * this function will never throw, and will always return a non-empty vector
+     * if device support is there, even if the device does not have calbration
+     * data loaded.
+     *
+     * \returns an empty vector if no power calibration is supported, or a
+     *          vector of length 2 with key and serial if it does.
+     */
+    virtual std::vector<std::string> get_tx_power_ref_keys(const size_t chan = 0) = 0;
+
+    /*! Return the available TX power range given the current configuration
+     *
+     * This will return the range of available power levels given the current
+     * frequency, gain profile, antenna, and whatever other settings may affect
+     * the available power ranges. Note that the available power range may
+     * change frequently, so don't assume an immutable range.
+     *
+     * \param chan The channel index
+     */
+    virtual meta_range_t get_tx_power_range(const size_t chan) = 0;
+
+};
+
+}}} // namespace uhd::rfnoc::rf_control