block_ctrl_base.hpp

Go to the documentation of this file.

//
// Copyright 2014-2016 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef INCLUDED_LIBUHD_BLOCK_CTRL_BASE_HPP
#define INCLUDED_LIBUHD_BLOCK_CTRL_BASE_HPP

#include <uhd/property_tree.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 <uhd/rfnoc/node_ctrl_base.hpp>
#include <uhd/rfnoc/block_id.hpp>
#include <uhd/rfnoc/stream_sig.hpp>
#include <uhd/rfnoc/blockdef.hpp>
#include <uhd/rfnoc/constants.hpp>
#include <boost/cstdint.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/lexical_cast.hpp>
#include <stdint.h>

namespace uhd {
    namespace rfnoc {
        namespace nocscript {
            // Forward declaration
            class block_iface;
        }


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

    std::map<size_t, uhd::wb_iface::sptr> 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;
    bool is_big_endian;
    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, boost::uint64_t noc_id = ~0);

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

    boost::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 boost::uint32_t reg, const boost::uint32_t data, const size_t port = 0);

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

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

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

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

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

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

    boost::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(const size_t port = 0/* reserved, currently not used */);

    /***********************************************************************
     * 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;
    };

    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);

    /***********************************************************************
     * Protected members
     **********************************************************************/

    uhd::property_tree::sptr _tree;

    uhd::fs_path _root_path;

    bool _transport_is_big_endian;

    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();

    /***********************************************************************
     * Private members
     **********************************************************************/
    std::map<size_t, wb_iface::sptr> _ctrl_ifaces;

    uint32_t _base_address;

    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 */
// vim: sw=4 et: