rfnoc: Allow MB controllers to init after blocks have initialized

This allows mb_controller childs to implement an init() call which
rfnoc_graph will call after the block initialization is complete.

rfnoc: graph/mb_controller: Add synchronization routine

This adds two new API calls:
* rfnoc_graph::synchronize_devices() and
* mb_controller::synchronize().

The purpose is to synchronize devices in time and/or phase, depending on
device capabilities. mb_controller childs can override or extend the
default implementation, which is to simply set time next PPS and verify
(similar to the set_time_unknown_pps() call in multi_usrp).

rfnoc: mb_controller: Add gpio_src API

Adds new API calls (get_gpio_src, get_gpio_srcs, set_gpio_src,
get_gpio_banks) to mb_controllers

2 files changed, 76 insertions, 10 deletions

diff --git a/host/include/uhd/rfnoc/mb_controller.hpp b/host/include/uhd/rfnoc/mb_controller.hpp
index a1c0f21aa..0269301ff 100644
--- a/host/include/uhd/rfnoc/mb_controller.hpp
+++ b/host/include/uhd/rfnoc/mb_controller.hpp
@@ -135,6 +135,10 @@ public:
     /**************************************************************************
      * Motherboard Control
      *************************************************************************/
+    /*! Run initializations of this motherboard that have to occur post-block init
+     */
+    virtual void init() {}
+
     /*! Get canonical name for this USRP motherboard
      *
      * \return a string representing the name
@@ -333,6 +337,51 @@ public:
      */
     virtual uhd::usrp::mboard_eeprom_t get_eeprom() = 0;
 
+    /*! Synchronize a list of motherboards
+     *
+     * \param mb_controllers A list of motherboard controllers to synchronize.
+     *                       Any motherboard controllers that could not be
+     *                       synchronized because they're incompatible with this
+     *                       motherboard controller are removed from the list.
+     *                       On return, the list should be (ideally) identical
+     *                       to its value at call time.
+     * \param quiet If true, don't print any errors or warnings if
+     *              synchronization fails.
+     * \returns true if all motherboards that were removed from \p mb_controllers
+     *          could be synchronized.
+     */
+    virtual bool synchronize(std::vector<mb_controller::sptr>& mb_controllers,
+        const uhd::time_spec_t& time_spec = uhd::time_spec_t(0.0),
+        const bool quiet                  = false);
+
+    /*! Return the list of GPIO banks that are controlled by this MB controller
+     *
+     * Note that this list may be empty. Only if the MB controller has any
+     * control over GPIOs, do the get listed here.
+     */
+    virtual std::vector<std::string> get_gpio_banks() const;
+
+    /*! Return a list of possible sources to drive GPIOs
+     *
+     * Sources can be "PS", for when an embedded device can drive the pins from
+     * software, "Radio#0", if a radio block can drive them, and so on.
+     */
+    virtual std::vector<std::string> get_gpio_srcs(const std::string& bank) const;
+
+    /*! Return the current sources for a given GPIO bank
+     */
+    virtual std::vector<std::string> get_gpio_src(const std::string& bank);
+
+    /*! Set the source for GPIO pins on a given bank.
+     *
+     * \throws uhd::key_error if the bank does not exist
+     * \throws uhd::value_error if the source does not exist
+     * \throws uhd::not_implemented_error if the current motherboard does not
+     *         support this feature
+     */
+    virtual void set_gpio_src(
+        const std::string& bank, const std::vector<std::string>& src);
+
 protected:
     /*! Stash away a timekeeper. This needs to be called by the implementer of
      * mb_controller.
diff --git a/host/include/uhd/rfnoc_graph.hpp b/host/include/uhd/rfnoc_graph.hpp
index 8a56d1c80..34091ddbd 100644
--- a/host/include/uhd/rfnoc_graph.hpp
+++ b/host/include/uhd/rfnoc_graph.hpp
@@ -14,6 +14,7 @@
 #include <uhd/stream.hpp>
 #include <uhd/transport/adapter_id.hpp>
 #include <uhd/types/device_addr.hpp>
+#include <uhd/types/time_spec.hpp>
 #include <uhd/utils/noncopyable.hpp>
 #include <boost/units/detail/utility.hpp> // for demangle
 #include <memory>
@@ -39,16 +40,6 @@ public:
 
     virtual ~rfnoc_graph() {}
 
-
-    //! Stuct to store information about which blocks are actually stored at a given port
-    //! on the crossbar
-    struct block_xbar_info
-    {
-        size_t xbar_port;
-        noc_id_t noc_id;
-        size_t inst_num;
-    };
-
     /******************************************
      * Factory
      ******************************************/
@@ -316,6 +307,32 @@ public:
     // See also uhd::rfnoc::mb_controller
     virtual std::shared_ptr<mb_controller> get_mb_controller(
         const size_t mb_index = 0) = 0;
+
+    /*! Run any routines necessary to synchronize devices
+     *
+     * The specific implementation of this call are device-specific. In all
+     * cases, it will set the time to a common value.
+     *
+     * Any application that requires any kind of phase or time alignment (if
+     * supported by the hardware) must call this before operation.
+     *
+     * \param time_spec The timestamp to be used to sync the devices. It will be
+     *                  an input to set_time_next_pps() on the motherboard
+     *                  controllers.
+     * \param quiet If true, there will be no errors or warnings printed if the
+     *              synchronization happens. This call will always be called
+     *              during initialization, but preconditions might not yet be
+     *              met (e.g., the time and reference sources might still be
+     *              internal), and will fail quietly in that case.
+     *
+     * \returns the success status of this call (true means devices are now
+     *          synchronized)
+     */
+    virtual bool synchronize_devices(
+        const uhd::time_spec_t& time_spec, const bool quiet) = 0;
+
+    //! Return a reference to the property tree
+    virtual uhd::property_tree::sptr get_tree(void) const = 0;
 }; // class rfnoc_graph
 
 }}; // namespace uhd::rfnoc