rfnoc: Introduce device-specific blocks

- Add device ID constants (e.g., E310 == 0xE310, X300 == 0xA300). These
  are stored in the device FPGA, and can be used for decisions later
- Blocks can be specific to a device. For example, x300_radio_control
  can only work on an X300 series device.
- Because blocks can be device-specific, all radio blocks can now share
  a common Noc-ID (0x12AD1000).
- The registry and factory functions are modified to acommodate for
  this.
  - The motherboard access is now also factored into the same registry
    macro.

3 files changed, 48 insertions, 68 deletions

diff --git a/host/lib/include/uhdlib/rfnoc/factory.hpp b/host/lib/include/uhdlib/rfnoc/factory.hpp
index be42a57e5..2bd1feb09 100644
--- a/host/lib/include/uhdlib/rfnoc/factory.hpp
+++ b/host/lib/include/uhdlib/rfnoc/factory.hpp
@@ -7,14 +7,16 @@
 #ifndef INCLUDED_LIBUHD_RFNOC_FACTORY_HPP
 #define INCLUDED_LIBUHD_RFNOC_FACTORY_HPP
 
-#include <uhd/rfnoc/registry.hpp>
+#include <uhd/rfnoc/defaults.hpp>
 #include <uhd/rfnoc/noc_block_base.hpp>
+#include <uhd/rfnoc/registry.hpp>
 
 namespace uhd { namespace rfnoc {
 
 struct block_factory_info_t
 {
     std::string block_name;
+    bool mb_access;
     std::string timebase_clk;
     std::string ctrlport_clk;
     registry::factory_t factory_fn;
@@ -30,11 +32,8 @@ public:
      * \returns a block_factory_info_t object
      * \throws uhd::lookup_error if no block is found
      */
-    static block_factory_info_t get_block_factory(noc_block_base::noc_id_t noc_id);
-
-    /*! Check if this block has requested access to the motherboard controller
-     */
-    static bool has_requested_mb_access(noc_block_base::noc_id_t noc_id);
+    static block_factory_info_t get_block_factory(
+        noc_id_t noc_id, device_type_t device_id);
 };
 
 }} /* namespace uhd::rfnoc */
diff --git a/host/lib/rfnoc/registry_factory.cpp b/host/lib/rfnoc/registry_factory.cpp
index 117b60e96..bf1bc60a5 100644
--- a/host/lib/rfnoc/registry_factory.cpp
+++ b/host/lib/rfnoc/registry_factory.cpp
@@ -7,8 +7,10 @@
 #include <uhd/exception.hpp>
 #include <uhd/rfnoc/registry.hpp>
 #include <uhd/rfnoc/defaults.hpp>
+#include <uhd/rfnoc/constants.hpp>
 #include <uhd/utils/static.hpp>
 #include <uhdlib/rfnoc/factory.hpp>
+#include <boost/functional/hash.hpp>
 #include <unordered_map>
 #include <iomanip>
 #include <iostream>
@@ -16,6 +18,10 @@
 
 using namespace uhd::rfnoc;
 
+/*! Pair type for device depended block definitions. */
+using block_device_pair_t = std::pair<noc_id_t, device_type_t>;
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // There are two registries:
 // - The "direct" registry, which is for blocks that do not have a block
@@ -24,8 +30,9 @@ using namespace uhd::rfnoc;
 //   descriptor file
 //
 // This is the direct registry:
-using block_direct_reg_t =
-    std::unordered_map<noc_block_base::noc_id_t, block_factory_info_t>;
+using block_direct_reg_t = std::unordered_map<block_device_pair_t,
+    block_factory_info_t,
+    boost::hash<block_device_pair_t>>;
 UHD_SINGLETON_FCN(block_direct_reg_t, get_direct_block_registry);
 //
 // This is the descriptor registry:
@@ -34,96 +41,68 @@ using block_descriptor_reg_t =
 UHD_SINGLETON_FCN(block_descriptor_reg_t, get_descriptor_block_registry);
 ///////////////////////////////////////////////////////////////////////////////
 
-///////////////////////////////////////////////////////////////////////////////
-// These registries are for blocks that have requested motherboard access
-using block_direct_mb_access_req_t = std::unordered_set<noc_block_base::noc_id_t>;
-UHD_SINGLETON_FCN(block_direct_mb_access_req_t, get_direct_block_mb_access_requested);
-//
-// This is the descriptor registry:
-using block_descriptor_mb_access_req_t = std::unordered_set<std::string>;
-UHD_SINGLETON_FCN(
-    block_descriptor_mb_access_req_t, get_descriptor_block_mb_access_requested);
-///////////////////////////////////////////////////////////////////////////////
-
 /******************************************************************************
  * Registry functions
  *
  * Note: Don't use UHD_LOG_*, since all of this can be executed in a static
  * fashion.
  *****************************************************************************/
-void registry::register_block_direct(noc_block_base::noc_id_t noc_id,
+void registry::register_block_direct(noc_id_t noc_id,
+    device_type_t device_id,
     const std::string& block_name,
+    bool mb_access,
     const std::string& timebase_clock,
     const std::string& ctrlport_clock,
     factory_t factory_fn)
 {
-    if (get_direct_block_registry().count(noc_id)) {
+    block_device_pair_t key{noc_id, device_id};
+    if (get_direct_block_registry().count(key)) {
         std::cerr
-            << "[REGISTRY] WARNING: Attempting to overwrite previously registered RFNoC "
-               "block with Noc-ID 0x"
-            << std::hex << noc_id << std::dec << std::endl;
+            << "[REGISTRY] WARNING: Attempting to overwrite previously "
+               "registered RFNoC block with noc_id,device_id: " << std::hex
+            << "0x" << noc_id << ", 0x" << device_id <<std::dec << std::endl;
         return;
     }
-    get_direct_block_registry().emplace(noc_id,
-        block_factory_info_t{
-            block_name, timebase_clock, ctrlport_clock, std::move(factory_fn)});
+    get_direct_block_registry().emplace(key,
+        block_factory_info_t{block_name,
+            mb_access,
+            timebase_clock,
+            ctrlport_clock,
+            std::move(factory_fn)});
 }
 
 void registry::register_block_descriptor(
     const std::string& block_key, factory_t factory_fn)
 {
     if (get_descriptor_block_registry().count(block_key)) {
-        std::cerr << "WARNING: Attempting to overwriting previously registered RFNoC "
-                     "block with block key"
-                  << block_key << std::endl;
+        std::cerr
+            << "[REGISTRY] WARNING: Attempting to overwrite previously "
+               "registered RFNoC block with block key"
+            << block_key << std::endl;
         return;
     }
     get_descriptor_block_registry().emplace(block_key, std::move(factory_fn));
 }
 
-void registry::request_mb_access(noc_block_base::noc_id_t noc_id)
-{
-    if (!get_direct_block_mb_access_requested().count(noc_id)) {
-        get_direct_block_mb_access_requested().emplace(noc_id);
-    }
-}
-
-void registry::request_mb_access(const std::string& block_key)
-{
-    if (!get_descriptor_block_mb_access_requested().count(block_key)) {
-        get_descriptor_block_mb_access_requested().emplace(block_key);
-    }
-}
-
 /******************************************************************************
  * Factory functions
  *****************************************************************************/
-block_factory_info_t factory::get_block_factory(noc_block_base::noc_id_t noc_id)
+block_factory_info_t factory::get_block_factory(noc_id_t noc_id, device_type_t device_id)
 {
     // First, check the descriptor registry
     // FIXME TODO
 
     // Second, check the direct registry
-    if (!get_direct_block_registry().count(noc_id)) {
-        UHD_LOG_WARNING("RFNOC::BLOCK_FACTORY",
-            "Could not find block with Noc-ID "
-                << std::hex << std::setw(sizeof(noc_block_base::noc_id_t) * 2) << noc_id);
-        noc_id = DEFAULT_NOC_ID;
-    }
-    return get_direct_block_registry().at(noc_id);
-}
+    block_device_pair_t key{noc_id, device_id};
 
-bool factory::has_requested_mb_access(noc_block_base::noc_id_t noc_id)
-{
-    if (get_direct_block_mb_access_requested().count(noc_id)) {
-        return true;
+    if (!get_direct_block_registry().count(key)) {
+        key = block_device_pair_t(noc_id, ANY_DEVICE);
     }
-
-    // FIXME tbw:
-    // - Map noc_id to block key
-    // - Check that key's descriptor
-    // - If that block has requested MB access, stash the noc ID in
-    // get_direct_block_mb_access_requested() for faster lookups in the future
-
-    return false;
+    if (!get_direct_block_registry().count(key)) {
+        UHD_LOG_WARNING("RFNOC::BLOCK_FACTORY",
+            "Could not find block with Noc-ID " << std::hex << "0x" << key.first << ", 0x"
+                                                << key.second << std::dec);
+        key = block_device_pair_t(DEFAULT_NOC_ID, ANY_DEVICE);
+    }
+    return get_direct_block_registry().at(key);
 }
diff --git a/host/lib/rfnoc/rfnoc_graph.cpp b/host/lib/rfnoc/rfnoc_graph.cpp
index c135247d3..bf49ca28b 100644
--- a/host/lib/rfnoc/rfnoc_graph.cpp
+++ b/host/lib/rfnoc/rfnoc_graph.cpp
@@ -10,6 +10,7 @@
 #include <uhd/rfnoc/noc_block_make_args.hpp>
 #include <uhd/rfnoc/node.hpp>
 #include <uhd/rfnoc_graph.hpp>
+#include <uhd/rfnoc/constants.hpp>
 #include <uhdlib/rfnoc/block_container.hpp>
 #include <uhdlib/rfnoc/factory.hpp>
 #include <uhdlib/rfnoc/graph.hpp>
@@ -377,7 +378,8 @@ private:
         // Iterate through and register each of the blocks in this mboard
         for (size_t portno = 0; portno < num_blocks; ++portno) {
             const auto noc_id       = mb_cz->get_noc_id(portno + first_block_port);
-            auto block_factory_info = factory::get_block_factory(noc_id);
+            const auto device_type  = mb_cz->get_device_type();
+            auto block_factory_info = factory::get_block_factory(noc_id, device_type);
             auto block_info         = mb_cz->get_block_info(portno + first_block_port);
             block_id_t block_id(mb_idx,
                 block_factory_info.block_name,
@@ -410,9 +412,9 @@ private:
             make_args_uptr->reg_iface          = block_reg_iface;
             make_args_uptr->tb_clk_iface       = tb_clk_iface;
             make_args_uptr->ctrlport_clk_iface = ctrlport_clk_iface;
-            make_args_uptr->mb_control         = (factory::has_requested_mb_access(noc_id)
+            make_args_uptr->mb_control         = block_factory_info.mb_access
                                               ? _mb_controllers.at(mb_idx)
-                                              : nullptr);
+                                              : nullptr;
             const uhd::fs_path block_path(uhd::fs_path("/blocks") / block_id.to_string());
             _tree->create<uint32_t>(block_path / "noc_id").set(noc_id);
             make_args_uptr->tree = _tree->subtree(block_path);