replay_block_control.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/config.hpp>
#include <uhd/rfnoc/noc_block_base.hpp>
 
namespace uhd { namespace rfnoc {
 
// doxygen tables need long long lines
// clang-format off
// clang-format on
class UHD_API replay_block_control : public noc_block_base
{
public:
    RFNOC_DECLARE_BLOCK(replay_block_control)
 
    static const uint16_t MINOR_COMPAT;
    static const uint16_t MAJOR_COMPAT;
 
    static const uint32_t REPLAY_ADDR_W;
    static const uint32_t REPLAY_BLOCK_OFFSET;
 
    static const uint32_t REG_COMPAT_ADDR;
    static const uint32_t REG_MEM_SIZE_ADDR;
    static const uint32_t REG_REC_RESTART_ADDR;
    static const uint32_t REG_REC_BASE_ADDR_LO_ADDR;
    static const uint32_t REG_REC_BASE_ADDR_HI_ADDR;
    static const uint32_t REG_REC_BUFFER_SIZE_LO_ADDR;
    static const uint32_t REG_REC_BUFFER_SIZE_HI_ADDR;
    static const uint32_t REG_REC_FULLNESS_LO_ADDR;
    static const uint32_t REG_REC_FULLNESS_HI_ADDR;
    static const uint32_t REG_PLAY_BASE_ADDR_LO_ADDR;
    static const uint32_t REG_PLAY_BASE_ADDR_HI_ADDR;
    static const uint32_t REG_PLAY_BUFFER_SIZE_LO_ADDR;
    static const uint32_t REG_PLAY_BUFFER_SIZE_HI_ADDR;
    static const uint32_t REG_PLAY_CMD_NUM_WORDS_LO_ADDR;
    static const uint32_t REG_PLAY_CMD_NUM_WORDS_HI_ADDR;
    static const uint32_t REG_PLAY_CMD_TIME_LO_ADDR;
    static const uint32_t REG_PLAY_CMD_TIME_HI_ADDR;
    static const uint32_t REG_PLAY_CMD_ADDR;
    static const uint32_t REG_PLAY_WORDS_PER_PKT_ADDR;
    static const uint32_t REG_PLAY_ITEM_SIZE_ADDR;
    static const uint32_t REG_REC_POS_LO_ADDR;
    static const uint32_t REG_REC_POS_HI_ADDR;
    static const uint32_t REG_PLAY_POS_LO_ADDR;
    static const uint32_t REG_PLAY_POS_HI_ADDR;
    static const uint32_t REG_PLAY_CMD_FIFO_SPACE_ADDR;
 
    static const uint32_t PLAY_CMD_STOP;
    static const uint32_t PLAY_CMD_FINITE;
    static const uint32_t PLAY_CMD_CONTINUOUS;
 
    static constexpr auto PLAY_CONTINUOUS{std::numeric_limits<size_t>::max()};
 
    /**************************************************************************
     * Replay Control API calls
     *************************************************************************/
    virtual void record(
        const uint64_t offset, const uint64_t size, const size_t port = 0) = 0;
 
    virtual void record_restart(const size_t port = 0) = 0;
 
    virtual void play(const uint64_t offset,
        const uint64_t size,
        const size_t port,
        const uhd::time_spec_t time_spec,
        const bool repeat) = 0;
 
    virtual void play(const uint64_t offset,
        const uint64_t size,
        const size_t port                = 0,
        const uhd::time_spec_t time_spec = uhd::time_spec_t(0.0),
        const size_t iterations          = 1) = 0;
 
    virtual void stop(const size_t port = 0) = 0;
 
    virtual uint64_t get_mem_size() const = 0;
 
    virtual uint64_t get_word_size() const = 0;
 
    /**************************************************************************
     * Record State API calls
     *************************************************************************/
    virtual uint64_t get_record_offset(const size_t port = 0) const = 0;
 
    virtual uint64_t get_record_size(const size_t port = 0) const = 0;
 
    virtual uint64_t get_record_fullness(const size_t port = 0) = 0;
 
    virtual uint64_t get_record_position(const size_t port = 0) = 0;
 
    virtual io_type_t get_record_type(const size_t port = 0) const = 0;
 
    virtual size_t get_record_item_size(const size_t port = 0) const = 0;
 
    virtual bool get_record_async_metadata(
        uhd::rx_metadata_t& metadata, const double timeout = 0.1) = 0;
 
    /**************************************************************************
     * Playback State API calls
     *************************************************************************/
    virtual uint64_t get_play_offset(const size_t port = 0) const = 0;
 
    virtual uint64_t get_play_size(const size_t port = 0) const = 0;
 
    virtual uint64_t get_play_position(const size_t port = 0) = 0;
 
    virtual uint32_t get_max_items_per_packet(const size_t port = 0) const = 0;
 
    virtual uint32_t get_max_packet_size(const size_t port = 0) const = 0;
 
    virtual io_type_t get_play_type(const size_t port = 0) const = 0;
 
    virtual size_t get_play_item_size(const size_t port = 0) const = 0;
 
    virtual bool get_play_async_metadata(
        uhd::async_metadata_t& metadata, const double timeout = 0.1) = 0;
 
    /**************************************************************************
     * Advanced Record Control API calls
     *************************************************************************/
    virtual void set_record_type(const io_type_t type, const size_t port = 0) = 0;
 
    /**************************************************************************
     * Advanced Playback Control API calls
     *************************************************************************/
    virtual void config_play(const uint64_t offset,
        const uint64_t size,
        const size_t port      = 0,
        const bool follow_mode = false) = 0;
 
    virtual void set_play_type(const io_type_t type, const size_t port = 0) = 0;
 
    virtual void set_max_items_per_packet(const uint32_t ipp, const size_t port = 0) = 0;
 
    virtual void set_max_packet_size(const uint32_t size, const size_t port = 0) = 0;
 
    virtual void issue_stream_cmd(
        const uhd::stream_cmd_t& stream_cmd, const size_t port = 0) = 0;
 
    virtual void post_input_action(
        const std::shared_ptr<uhd::rfnoc::action_info>& action, const size_t port) = 0;
 
    virtual void post_output_action(
        const std::shared_ptr<uhd::rfnoc::action_info>& action, const size_t port) = 0;
};
 
}} /* namespace uhd::rfnoc */