mpm: Factor out common code between E31x_db and Neon classes

These classes share a *lot* of common code, due to them both being
AD9361-based devices. This code is now factored out into a single file.

1 files changed, 170 insertions, 0 deletions

diff --git a/mpm/python/usrp_mpm/dboard_manager/ad936x_db.py b/mpm/python/usrp_mpm/dboard_manager/ad936x_db.py
new file mode 100644
index 000000000..092d6c4de
--- /dev/null
+++ b/mpm/python/usrp_mpm/dboard_manager/ad936x_db.py
@@ -0,0 +1,170 @@
+#
+# Copyright 2021 Ettus Research, a National Instruments Brand
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+"""
+Common daughterboard code for E310 and E320
+"""
+
+from usrp_mpm import lib # Pulls in everything from C++-land
+from usrp_mpm.mpmutils import async_exec
+
+class AD936xDboard:
+    """
+    Holds all common code between E310 and E320 (AD936x-based MPM devices)
+    """
+    MIN_MASTER_CLK_RATE = 220e3
+    MAX_MASTER_CLK_RATE = 61.44e6
+
+    def __init__(self, mb_regs_getter):
+        self.rfic = None
+        self.log = None
+        self.master_clock_rate = None
+        self.swap_fe = False
+        self._mb_regs_getter = mb_regs_getter
+
+    def tear_down_rfic(self):
+        """
+        De-init this object as much as possible.
+        """
+        self.log.trace("Tearing down E3xx DB object!")
+        for method in [
+                x for x in dir(self.rfic)
+                if not x.startswith("_") and callable(getattr(self.rfic, x))]:
+            delattr(self, method)
+        self.rfic = None
+
+    def _init_cat_api(self, rfic):
+        """
+        Propagate the C++ Catalina API into Python land.
+        """
+        self.rfic = rfic
+        def export_method(obj, method):
+            " Export a method object, including docstring "
+            meth_obj = getattr(obj, method)
+            def func(*args):
+                " Functor for storing docstring too "
+                return meth_obj(*args)
+            func.__doc__ = meth_obj.__doc__
+            return func
+        self.log.trace("Forwarding AD9361 methods to daughterboard class...")
+        for method in [
+                x for x in dir(self.rfic)
+                if not x.startswith("_") and \
+                        callable(getattr(self.rfic, x))]:
+            self.log.trace("adding {}".format(method))
+            setattr(self, method, export_method(rfic, method))
+
+    def init_rfic(self, master_clock_rate):
+        """
+        Initialize chains and clock rate on AD936x
+        """
+        assert self.MIN_MASTER_CLK_RATE <= master_clock_rate <= self.MAX_MASTER_CLK_RATE, \
+            "Invalid master clock rate: {:.02f} MHz".format(
+                master_clock_rate / 1e6)
+        master_clock_rate_changed = master_clock_rate != self.master_clock_rate
+        if master_clock_rate_changed:
+            self.master_clock_rate = master_clock_rate
+            self.log.debug("Updating master clock rate to {:.02f} MHz!".format(
+                self.master_clock_rate / 1e6
+            ))
+        # Some default chains on -- needed for setup purposes
+        self.rfic.set_active_chains(True, False, True, False)
+        self.set_catalina_clock_rate(self.master_clock_rate)
+
+    def get_ad9361_lo_lock(self, which):
+        """
+        Return LO lock status (Boolean!) of AD9361. 'which' must be
+        either 'tx' or 'rx'
+        """
+        mboard_regs_control = self._mb_regs_getter()
+        if which == "tx":
+            return mboard_regs_control.get_ad9361_tx_lo_lock()
+        if which == "rx":
+            return mboard_regs_control.get_ad9361_rx_lo_lock()
+        self.log.warning("get_ad9361_lo_lock(): Invalid which param `{}'"
+                         .format(which))
+        return False
+
+    def get_lo_lock_sensor(self, which):
+        """
+        Get sensor dict with LO lock status
+        """
+        self.log.trace("Reading LO Lock.")
+        lo_locked = self.get_ad9361_lo_lock(which)
+        return {
+            'name': 'ad9361_lock',
+            'type': 'BOOLEAN',
+            'unit': 'locked' if lo_locked else 'unlocked',
+            'value': str(lo_locked).lower(),
+        }
+
+    def get_rx_lo_lock_sensor(self, _chan):
+        """
+        RX-specific version of get_lo_lock_sensor() (for UHD API)
+        """
+        return self.get_lo_lock_sensor('rx')
+
+    def get_tx_lo_lock_sensor(self, _chan):
+        """
+        TX-specific version of get_lo_lock_sensor() (for UHD API)
+        """
+        return self.get_lo_lock_sensor('tx')
+
+    def get_catalina_temp_sensor(self, _):
+        """
+        Get temperature sensor reading of Catalina.
+        """
+        # Note: the unused argument is channel
+        self.log.trace("Reading Catalina temperature.")
+        return {
+            'name': 'ad9361_temperature',
+            'type': 'REALNUM',
+            'unit': 'C',
+            'value': str(self.rfic.get_temperature())
+        }
+
+    def get_rssi_val(self, which):
+        """
+        Return the current RSSI of `which` chain in Catalina
+        """
+        return self.rfic.get_rssi(which)
+
+    def get_rssi_sensor(self, chan):
+        """
+        Return a sensor dictionary containing the current RSSI per channel
+        in the RFIC
+        """
+        which = {
+            # No frontend swap:
+            False: {0: 'RX1', 1: 'RX2'},
+            # Frontend swap:
+            True:  {0: 'RX2', 1: 'RX1'},
+        }[self.swap_fe][chan]
+        return {
+            'name': 'rssi',
+            'type': 'REALNUM',
+            'unit': 'dB',
+            'value': str(self.get_rssi_val(which)),
+        }
+
+    def set_catalina_clock_rate(self, rate):
+        """
+        Async call to catalina set_clock_rate
+        """
+        self.log.trace("Setting Clock rate to {}".format(rate))
+        async_exec(lib.ad9361, "set_clock_rate", self.rfic, rate)
+        return rate
+
+    def catalina_tune(self, which, freq):
+        """
+        Async call to catalina tune
+        """
+        self.log.trace("Tuning {} {}".format(which, freq))
+        async_exec(lib.ad9361, "tune", self.rfic, which, freq)
+        return self.rfic.get_freq(which)
+
+    def get_master_clock_rate(self):
+        " Return master clock rate (== sampling rate) "
+        return self.master_clock_rate