block_ctrl_base.hpp

Go to the documentation of this file.

//
// Copyright 2014-2016 Ettus Research LLC
// Copyright 2018 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: GPL-3.0-or-later
//

#ifndef INCLUDED_LIBUHD_BLOCK_CTRL_BASE_HPP
#define INCLUDED_LIBUHD_BLOCK_CTRL_BASE_HPP

#include <uhd/property_tree.hpp>
#include <uhd/rfnoc/block_id.hpp>
#include <uhd/rfnoc/blockdef.hpp>
#include <uhd/rfnoc/constants.hpp>
#include <uhd/rfnoc/node_ctrl_base.hpp>
#include <uhd/rfnoc/stream_sig.hpp>
#include <uhd/stream.hpp>
#include <uhd/types/sid.hpp>
#include <uhd/types/stream_cmd.hpp>
#include <uhd/types/wb_iface.hpp>
#include <uhd/utils/static.hpp>
#include <stdint.h>
#include <boost/shared_ptr.hpp>

namespace uhd { namespace rfnoc {
// Forward declarations
class ctrl_iface;
namespace nocscript {
class block_iface;
}


// TODO: Move this out of public section
struct make_args_t
{
    make_args_t(const std::string& key = "")
        : device_index(0), block_name(""), block_key(key)
    {
    }

    std::map<size_t, boost::shared_ptr<ctrl_iface> > ctrl_ifaces;
    uint32_t base_address;
    size_t device_index;
    //  property tree is /mboards/0, pass a subtree starting at /mboards/0
    //  to the constructor.
    uhd::property_tree::sptr tree;
    std::string block_name;
    std::string block_key;
};

// block class
#define UHD_RFNOC_BLOCK_OBJECT(class_name) typedef boost::shared_ptr<class_name> sptr;

#define UHD_RFNOC_BLOCK_CONSTRUCTOR(CLASS_NAME) \
    CLASS_NAME##_impl(const make_args_t& make_args) : block_ctrl_base(make_args)

// after the class definition
#define UHD_RFNOC_BLOCK_REGISTER(CLASS_NAME, BLOCK_NAME)                             \
    block_ctrl_base::sptr CLASS_NAME##_make(const make_args_t& make_args)            \
    {                                                                                \
        return block_ctrl_base::sptr(new CLASS_NAME##_impl(make_args));              \
    }                                                                                \
    UHD_STATIC_BLOCK(register_rfnoc_##CLASS_NAME)                                    \
    {                                                                                \
        uhd::rfnoc::block_ctrl_base::register_block(&CLASS_NAME##_make, BLOCK_NAME); \
    }

class UHD_RFNOC_API block_ctrl_base;
class block_ctrl_base : virtual public node_ctrl_base
{
public:
    /***********************************************************************
     * Types
     **********************************************************************/
    typedef boost::shared_ptr<block_ctrl_base> sptr;
    typedef boost::function<sptr(const make_args_t&)> make_t;

    /***********************************************************************
     * Factory functions
     **********************************************************************/

    static void register_block(const make_t& make, const std::string& name);

    static sptr make(const make_args_t& make_args, uint64_t noc_id = ~0);

    /***********************************************************************
     * Block Communication and Control
     *
     * These functions do not require communication with the FPGA.
     **********************************************************************/

    uint32_t get_address(size_t block_port = 0);

    block_id_t get_block_id() const
    {
        return _block_id;
    };

    std::string unique_id() const
    {
        return _block_id.to_string();
    };

    /***********************************************************************
     * FPGA control & communication
     **********************************************************************/

    std::vector<size_t> get_ctrl_ports() const;

    void sr_write(const uint32_t reg, const uint32_t data, const size_t port = 0);

    void sr_write(const std::string& reg, const uint32_t data, const size_t port = 0);

    uint64_t sr_read64(const settingsbus_reg_t reg, const size_t port = 0);

    uint32_t sr_read32(const settingsbus_reg_t reg, const size_t port = 0);

    uint64_t user_reg_read64(const uint32_t addr, const size_t port = 0);

    uint64_t user_reg_read64(const std::string& reg, const size_t port = 0);

    uint32_t user_reg_read32(const uint32_t addr, const size_t port = 0);

    uint32_t user_reg_read32(const std::string& reg, const size_t port = 0);


    void set_command_time(const time_spec_t& time_spec, const size_t port = ANY_PORT);

    time_spec_t get_command_time(const size_t port = 0);

    void set_command_tick_rate(const double tick_rate, const size_t port = ANY_PORT);

    void clear_command_time(const size_t port);

    void clear();

    /***********************************************************************
     * Argument handling
     **********************************************************************/
    void set_args(const uhd::device_addr_t& args, const size_t port = 0);

    // data type using by looking up its type in the block definition.
    void set_arg(const std::string& key, const std::string& val, const size_t port = 0);

    template <typename T>
    void set_arg(const std::string& key, const T& val, const size_t port = 0)
    {
        _tree->access<T>(get_arg_path(key, port) / "value").set(val);
    }

    uhd::device_addr_t get_args(const size_t port = 0) const;

    std::string get_arg(const std::string& key, const size_t port = 0) const;

    template <typename T> T get_arg(const std::string& key, const size_t port = 0) const
    {
        return _tree->access<T>(get_arg_path(key, port) / "value").get();
    }

    std::string get_arg_type(const std::string& key, const size_t port = 0) const;

protected:
    /***********************************************************************
     * Structors
     **********************************************************************/
    block_ctrl_base(void){}; // To allow pure virtual (interface) sub-classes
    virtual ~block_ctrl_base();

    block_ctrl_base(const make_args_t& make_args);

    /***********************************************************************
     * Helpers
     **********************************************************************/
    stream_sig_t _resolve_port_def(const blockdef::port_t& port_def) const;

    uhd::fs_path get_arg_path(const std::string& key, size_t port = 0) const
    {
        return _root_path / "args" / port / key;
    };

    timed_wb_iface::sptr get_ctrl_iface(const size_t block_port);

    /***********************************************************************
     * Hooks & Derivables
     **********************************************************************/

    // than reset register SR_CLEAR_TX_FC.
    virtual void _clear(const size_t port = 0);

    // setting the command time
    virtual void _set_command_time(
        const time_spec_t& time_spec, const size_t port = ANY_PORT);
    /***********************************************************************
     * Protected members
     **********************************************************************/

    uhd::property_tree::sptr _tree;

    uhd::fs_path _root_path;

    blockdef::sptr _block_def;

private:
    void _init_port_defs(const std::string& direction,
        blockdef::ports_t ports,
        const size_t first_port_index = 0);

    void _init_block_args();

    double get_command_tick_rate(const size_t port);

    void _start_drain(const size_t port = 0);

    bool _flush(const size_t port = 0);

    /***********************************************************************
     * Private members
     **********************************************************************/
    std::map<size_t, boost::shared_ptr<ctrl_iface> > _ctrl_ifaces;
    std::map<size_t, time_spec_t> _cmd_timespecs;
    std::map<size_t, double> _cmd_tickrates;

    uint32_t _base_address;

    uint64_t _noc_id;

    uint64_t _compat_num;

    block_id_t _block_id;

    boost::shared_ptr<nocscript::block_iface> _nocscript_iface;
}; /* class block_ctrl_base */

}} /* namespace uhd::rfnoc */

#endif /* INCLUDED_LIBUHD_BLOCK_CTRL_BASE_HPP */