noc_block_base.hpp

Go to the documentation of this file.

//
// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#pragma once
 
#include <uhd/config.hpp>
#include <uhd/property_tree.hpp>
#include <uhd/rfnoc/block_id.hpp>
#include <uhd/rfnoc/defaults.hpp>
#include <uhd/rfnoc/node.hpp>
#include <uhd/rfnoc/register_iface_holder.hpp>
#include <uhd/types/device_addr.hpp>
 
#define RFNOC_BLOCK_CONSTRUCTOR(CLASS_NAME) \
    CLASS_NAME##_impl(make_args_ptr make_args) : CLASS_NAME(std::move(make_args))
 
#define RFNOC_DECLARE_BLOCK(CLASS_NAME)       \
    using sptr = std::shared_ptr<CLASS_NAME>; \
    CLASS_NAME(make_args_ptr make_args) : noc_block_base(std::move(make_args)) {}
 
namespace uhd { namespace rfnoc {
 
class clock_iface;
class mb_controller;
 
class UHD_API noc_block_base : public node_t, public register_iface_holder
{
public:
    using sptr = std::shared_ptr<noc_block_base>;
 
    struct make_args_t;
 
    using make_args_ptr = std::unique_ptr<make_args_t>;
 
    virtual ~noc_block_base();
 
    /**************************************************************************
     * node_t API calls
     *************************************************************************/
    std::string get_unique_id() const
    {
        return get_block_id().to_string();
    }
 
    // information stored in the global register space.
    //
    // Note: This may be overridden by the block (e.g., the X300 radio may not
    // have all ports available if no TwinRX board is plugged in), but the
    // subclassed version may never report more ports than this.
    size_t get_num_input_ports() const
    {
        return _num_input_ports;
    }
 
    // information stored in the global register space.
    //
    // Note: This may be overridden by the block (e.g., the X300 radio may not
    // have all ports available if no TwinRX board is plugged in), but the
    // subclassed version may never report more ports than this.
    size_t get_num_output_ports() const
    {
        return _num_output_ports;
    }
 
    /**************************************************************************
     * RFNoC-block specific API calls
     *************************************************************************/
    noc_id_t get_noc_id() const
    {
        return _noc_id;
    }
 
    const block_id_t& get_block_id() const
    {
        return _block_id;
    }
 
    double get_tick_rate() const;
 
    size_t get_mtu(const res_source_info& edge);
 
    uhd::device_addr_t get_block_args() const
    {
        return _block_args;
    }
 
    uhd::property_tree::sptr& get_tree() const
    {
        return _tree;
    }
 
    uhd::property_tree::sptr& get_tree()
    {
        return _tree;
    }
 
protected:
    noc_block_base(make_args_ptr make_args);
 
    //
    // - The new number of ports may not exceed the old number. This can only
    //   be used to 'decrease' the number of ports.
    // - This is considered an 'advanced' API and should rarely be called by
    //   blocks. See also get_num_output_ports().
    //
    // \throws uhd::value_error if \p num_ports is larger than the current
    //         number of ports.
    void set_num_input_ports(const size_t num_ports);
 
    //
    // - The new number of ports may not exceed the old number. This can only
    //   be used to 'decrease' the number of ports.
    // - This is considered an 'advanced' API and should rarely be called by
    //   blocks. An example of where this is useful is the X310 radio block,
    //   which has 2 output ports, but only 1 is useful for UBX/SBX/WBX boards
    //   (i.e., boards with 1 frontend). In that case, software can make a
    //   determination to 'invalidate' one of the ports.
    //
    // \throws uhd::value_error if \p num_ports is larger than the current
    //         number of ports.
    void set_num_output_ports(const size_t num_ports);
 
    void set_tick_rate(const double tick_rate);
 
    void set_mtu_forwarding_policy(const forwarding_policy_t policy);
 
    void set_mtu(const res_source_info& edge, const size_t new_mtu);
 
    property_base_t* get_mtu_prop_ref(const res_source_info& edge);
 
    std::shared_ptr<mb_controller> get_mb_controller();
 
    virtual void deinit();
 
private:
    void _set_tick_rate(const double tick_rate);
 
    void shutdown();
 
    /**************************************************************************
     * Attributes
     **************************************************************************/
    noc_id_t _noc_id;
 
    //
    // The framework will guarantee that no one else has the same block ID
    block_id_t _block_id;
 
    size_t _num_input_ports;
 
    size_t _num_output_ports;
 
    // for all in- and output edges.
    std::vector<property_t<double>> _tick_rate_props;
 
    forwarding_policy_t _mtu_fwd_policy = forwarding_policy_t::DROP;
 
    // for all in- and output edges.
    std::vector<property_t<size_t>> _mtu_props;
 
    std::unordered_map<res_source_info, size_t> _mtu;
 
    std::shared_ptr<clock_iface> _ctrlport_clock_iface;
 
    std::shared_ptr<clock_iface> _tb_clock_iface;
 
    // block had requested and was granted access
    std::shared_ptr<mb_controller> _mb_controller;
 
    const uhd::device_addr_t _block_args;
 
    //
    // It is mutable because _tree->access<>(..).get() is not const, but we
    // need to do just that in some const contexts
    mutable uhd::property_tree::sptr _tree;
 
}; // class noc_block_base
 
}} /* namespace uhd::rfnoc */
 
#include <uhd/rfnoc/noc_block_make_args.hpp>