register_iface.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/types/device_addr.hpp>
#include <uhd/types/time_spec.hpp>
#include <boost/optional.hpp>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <vector>
 
namespace uhd { namespace rfnoc {
 
struct custom_register_space
{
    uint32_t end_addr;
    std::function<void(uint32_t, uint32_t)> poke_fn;
    std::function<uint32_t(uint32_t)> peek_fn;
};
 
struct register_iface_stats
{
    uint64_t ctrl_packets_sent = 0;
    uint64_t ack_packets_received = 0;
    uint64_t async_packets_received = 0;
    uint64_t ack_packets_sent = 0;
    uint64_t ctrl_dropped = 0;
    uint64_t ctrl_out_of_sequence = 0;
    ssize_t buffer_fullness = 0;
 
    std::string UHD_API to_string() const;
};
 
class register_iface
{
public:
    using sptr = std::shared_ptr<register_iface>;
 
    virtual ~register_iface() = default;
 
    using async_msg_validator_t =
        std::function<bool(uint32_t addr, const std::vector<uint32_t>& data)>;
 
    using async_msg_callback_t = std::function<void(
        uint32_t addr, const std::vector<uint32_t>& data, std::optional<uint64_t>)>;
 
    using async_msg_callback_legacy_t = std::function<void(
        uint32_t addr, const std::vector<uint32_t>& data, boost::optional<uint64_t>)>;
 
    virtual void poke32(uint32_t addr,
        uint32_t data,
        uhd::time_spec_t time = uhd::time_spec_t::ASAP,
        bool ack              = false) = 0;
 
    void poke64(uint32_t addr,
        uint64_t data,
        time_spec_t time = uhd::time_spec_t::ASAP,
        bool ack         = false)
    {
        block_poke32(addr,
            {uint32_t(data & 0xFFFFFFFF), uint32_t((data >> 32) & 0xFFFFFFFF)},
            time,
            ack);
    }
 
    virtual void multi_poke32(const std::vector<uint32_t> addrs,
        const std::vector<uint32_t> data,
        uhd::time_spec_t time = uhd::time_spec_t::ASAP,
        bool ack              = false) = 0;
 
    virtual void block_poke32(uint32_t first_addr,
        const std::vector<uint32_t> data,
        uhd::time_spec_t time = uhd::time_spec_t::ASAP,
        bool ack              = false) = 0;
 
    virtual void burst_poke32(uint32_t addr,
        const std::vector<uint32_t> data,
        uhd::time_spec_t time = uhd::time_spec_t::ASAP,
        bool ack              = false) = 0;
 
    virtual uint32_t peek32(uint32_t addr, time_spec_t time = uhd::time_spec_t::ASAP) = 0;
 
    uint64_t peek64(uint32_t addr, time_spec_t time = uhd::time_spec_t::ASAP)
    {
        const auto vals = block_peek32(addr, 2, time);
        return uint64_t(vals[0]) | (uint64_t(vals[1]) << 32);
    }
 
    virtual std::vector<uint32_t> block_peek32(uint32_t first_addr,
        size_t length,
        time_spec_t time = uhd::time_spec_t::ASAP) = 0;
 
    virtual std::vector<uint32_t> burst_peek32(
        uint32_t addr, size_t length, time_spec_t time = uhd::time_spec_t::ASAP) = 0;
 
    virtual std::optional<uint32_t> poll32(uint32_t addr,
        uint32_t data,
        uint32_t mask,
        time_spec_t timeout,
        time_spec_t time = uhd::time_spec_t::ASAP,
        bool ack         = false) = 0;
 
 
    virtual void sleep(time_spec_t duration, bool ack = false) = 0;
 
    virtual void register_async_msg_validator(async_msg_validator_t callback_f) = 0;
 
    virtual void register_async_msg_handler(async_msg_callback_t callback_f) = 0;
 
    [[deprecated("Prefer std::optional over boost::optional.")]] void
    register_async_msg_handler(async_msg_callback_legacy_t callback_f)
    {
        auto wrapper_f = [callback_f](uint32_t addr,
                             const std::vector<uint32_t>& data,
                             std::optional<uint64_t> timestamp) {
            boost::optional<uint64_t> legacy_timestamp;
            if (timestamp.has_value()) {
                legacy_timestamp = timestamp.value();
            }
            callback_f(addr, data, legacy_timestamp);
        };
        register_async_msg_handler(wrapper_f);
    }
 
    virtual void set_policy(const std::string& name, const uhd::device_addr_t& args) = 0;
 
    virtual uint16_t get_src_epid() const = 0;
 
    virtual uint16_t get_port_num() const = 0;
 
    virtual void define_custom_register_space(const uint32_t start_addr,
        const uint32_t length,
        std::function<void(uint32_t, uint32_t)> poke_fn,
        std::function<uint32_t(uint32_t)> peek_fn) = 0;
 
    virtual register_iface_stats get_stats() const = 0;
 
}; // class register_iface
 
}} /* namespace uhd::rfnoc */