multichan_register_iface.hpp

Go to the documentation of this file.

//
// Copyright 2020 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//

#pragma once

#include <uhd/rfnoc/register_iface.hpp>
#include <uhd/rfnoc/register_iface_holder.hpp>
#include <uhd/types/device_addr.hpp>
#include <uhd/types/time_spec.hpp>
#include <cstdint>
#include <functional>
#include <memory>
#include <vector>

namespace uhd { namespace rfnoc {

class multichan_register_iface
{
public:
    using sptr = std::shared_ptr<multichan_register_iface>;

    multichan_register_iface(register_iface_holder& reg_iface_holder,
        const uint32_t block_base_addr,
        const size_t block_size)
        : _reg_iface_holder(reg_iface_holder)
        , _block_base_addr(block_base_addr)
        , _block_size(block_size)
    {
    }

    ~multichan_register_iface() = default;

    inline void poke32(uint32_t addr,
        uint32_t data,
        const size_t instance = 0,
        uhd::time_spec_t time = uhd::time_spec_t::ASAP,
        bool ack              = false)
    {
        _reg_iface_holder.regs().poke32(_get_addr(addr, instance), data, time, ack);
    }

    inline void poke64(uint32_t addr,
        uint64_t data,
        const size_t instance = 0,
        time_spec_t time      = uhd::time_spec_t::ASAP,
        bool ack              = false)
    {
        _reg_iface_holder.regs().poke64(_get_addr(addr, instance), data, time, ack);
    }

    inline void multi_poke32(const std::vector<uint32_t> addrs,
        const std::vector<uint32_t> data,
        const size_t instance = 0,
        uhd::time_spec_t time = uhd::time_spec_t::ASAP,
        bool ack              = false)
    {
        std::vector<uint32_t> abs_addrs(addrs.size());
        std::transform(addrs.begin(),
            addrs.end(),
            abs_addrs.begin(),
            [this, instance](
                uint32_t addr) -> uint32_t { return _get_addr(addr, instance); });
        _reg_iface_holder.regs().multi_poke32(abs_addrs, data, time, ack);
    }

    inline void block_poke32(uint32_t first_addr,
        const std::vector<uint32_t> data,
        const size_t instance = 0,
        uhd::time_spec_t time = uhd::time_spec_t::ASAP,
        bool ack              = false)
    {
        _reg_iface_holder.regs().block_poke32(
            _get_addr(first_addr, instance), data, time, ack);
    }

    inline uint32_t peek32(uint32_t addr,
        const size_t instance = 0,
        time_spec_t time      = uhd::time_spec_t::ASAP)
    {
        return _reg_iface_holder.regs().peek32(_get_addr(addr, instance), time);
    }

    inline uint64_t peek64(uint32_t addr,
        const size_t instance = 0,
        time_spec_t time      = uhd::time_spec_t::ASAP)
    {
        return _reg_iface_holder.regs().peek64(_get_addr(addr, instance), time);
    }

    inline std::vector<uint32_t> block_peek32(uint32_t first_addr,
        size_t length,
        const size_t instance = 0,
        time_spec_t time      = uhd::time_spec_t::ASAP)
    {
        return _reg_iface_holder.regs().block_peek32(
            _get_addr(first_addr, instance), length, time);
    }

    inline void poll32(uint32_t addr,
        uint32_t data,
        uint32_t mask,
        time_spec_t timeout,
        const size_t instance = 0,
        time_spec_t time      = uhd::time_spec_t::ASAP,
        bool ack              = false)
    {
        _reg_iface_holder.regs().poll32(
            _get_addr(addr, instance), data, mask, timeout, time, ack);
    }

private:
    register_iface_holder& _reg_iface_holder;
    uint32_t _block_base_addr;
    size_t _block_size;

    inline uint32_t _get_addr(const uint32_t reg_offset, const size_t instance) const
    {
        return _block_base_addr + reg_offset + _block_size * instance;
    }

}; // class multichan_register_iface

}} /* namespace uhd::rfnoc */