RFNoC: Add Replay API and example

2 files changed, 184 insertions, 0 deletions

diff --git a/host/lib/rfnoc/CMakeLists.txt b/host/lib/rfnoc/CMakeLists.txt
index 527c99e14..f98518272 100644
--- a/host/lib/rfnoc/CMakeLists.txt
+++ b/host/lib/rfnoc/CMakeLists.txt
@@ -40,6 +40,7 @@ LIBUHD_APPEND_SOURCES(
     ${CMAKE_CURRENT_SOURCE_DIR}/radio_ctrl_impl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/siggen_block_ctrl_impl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/dma_fifo_block_ctrl_impl.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/replay_block_ctrl_impl.cpp
 )
 
 INCLUDE_SUBDIRECTORY(nocscript)
diff --git a/host/lib/rfnoc/replay_block_ctrl_impl.cpp b/host/lib/rfnoc/replay_block_ctrl_impl.cpp
new file mode 100644
index 000000000..a78632bf9
--- /dev/null
+++ b/host/lib/rfnoc/replay_block_ctrl_impl.cpp
@@ -0,0 +1,183 @@
+//
+// Copyright 2016 Ettus Research LLC
+// Copyright 2018 Ettus Research, a National Instruments Company
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#include <uhd/rfnoc/replay_block_ctrl.hpp>
+#include <mutex>
+
+using namespace uhd;
+using namespace uhd::rfnoc;
+
+class replay_block_ctrl_impl : public replay_block_ctrl
+{
+public:
+    static const uint32_t REPLAY_WORD_SIZE    = 8;      // In bytes
+    static const uint32_t SAMPLES_PER_WORD    = 2;
+    static const uint32_t BYTES_PER_SAMPLE    = 4;
+    static const uint32_t WORDS_PER_PACKET    = 128;
+    static const uint32_t DEFAULT_BUFFER_SIZE = 32*1024*1024;
+    static const uint32_t DEFAULT_WPP         = 182;
+    static const uint32_t DEFAULT_SPP         = DEFAULT_WPP * SAMPLES_PER_WORD;
+
+
+    UHD_RFNOC_BLOCK_CONSTRUCTOR(replay_block_ctrl)
+    {
+        _num_channels = get_input_ports().size();
+        _params.resize(_num_channels);
+        for(size_t chan = 0; chan < _params.size(); chan++) {
+            _params[chan].words_per_packet = DEFAULT_WPP;
+            sr_write("RX_CTRL_MAXLEN", WORDS_PER_PACKET, chan);
+
+            // Configure replay channels to be adjacent DEFAULT_BUFFER_SIZE'd blocks
+            _params[chan].rec_base_addr  = chan*DEFAULT_BUFFER_SIZE;
+            _params[chan].play_base_addr = chan*DEFAULT_BUFFER_SIZE;
+            _params[chan].rec_buffer_size  = DEFAULT_BUFFER_SIZE;
+            _params[chan].play_buffer_size = DEFAULT_BUFFER_SIZE;
+            sr_write("REC_BASE_ADDR", _params[chan].rec_base_addr, chan);
+            sr_write("REC_BUFFER_SIZE", _params[chan].rec_buffer_size, chan);
+            sr_write("PLAY_BASE_ADDR", _params[chan].play_base_addr, chan);
+            sr_write("PLAY_BUFFER_SIZE", _params[chan].play_buffer_size, chan);
+        }
+    }
+
+    
+   /**************************************************************************
+    * API Calls
+    **************************************************************************/
+    
+    void config_record(const uint32_t base_addr, const uint32_t size, const size_t chan) {
+        std::lock_guard<std::mutex> lock(_mutex);
+        _params[chan].rec_base_addr = base_addr;
+        _params[chan].rec_buffer_size = size;
+        sr_write("REC_BASE_ADDR", base_addr, chan);
+        sr_write("REC_BUFFER_SIZE", size, chan);
+        sr_write("REC_RESTART", 0, chan);
+    }
+    
+    void config_play(const uint32_t base_addr, const uint32_t size, const size_t chan) {
+        std::lock_guard<std::mutex> lock(_mutex);
+        _params[chan].play_base_addr = base_addr;
+        _params[chan].play_buffer_size = size;
+        sr_write("PLAY_BASE_ADDR", base_addr, chan);
+        sr_write("PLAY_BUFFER_SIZE", size, chan);
+    }
+
+    void record_restart(const size_t chan) {
+        std::lock_guard<std::mutex> lock(_mutex);
+        sr_write("REC_RESTART", 0, chan);
+    }
+        
+    uint32_t get_record_addr(const size_t chan) {
+        return _params[chan].rec_base_addr;
+    }
+    
+    uint32_t get_record_size(const size_t chan) {
+        return _params[chan].rec_buffer_size;
+    }
+
+    uint32_t get_record_fullness(const size_t chan) {
+        return user_reg_read32("REC_FULLNESS", chan);
+    }
+
+    uint32_t get_play_addr(const size_t chan) {
+        return _params[chan].play_base_addr;
+    }
+    
+    uint32_t get_play_size(const size_t chan) {
+        return _params[chan].play_buffer_size;
+    }
+
+    void set_words_per_packet(const uint32_t num_words, const size_t chan) {
+        std::lock_guard<std::mutex> lock(_mutex);
+        _params[chan].words_per_packet = num_words;
+        sr_write("RX_CTRL_MAXLEN", num_words, chan);
+    }
+
+    uint32_t get_words_per_packet(const size_t chan) {
+        return _params[chan].words_per_packet;
+    }
+    
+    
+   /***************************************************************************
+    * Radio-like Streamer
+    **************************************************************************/
+    
+    void issue_stream_cmd(
+        const uhd::stream_cmd_t &stream_cmd,
+        const size_t chan
+    ) {
+        std::lock_guard<std::mutex> lock(_mutex);
+        UHD_RFNOC_BLOCK_TRACE()
+            << "replay_block_ctrl_impl::issue_stream_cmd() " << chan
+            << " " << char(stream_cmd.stream_mode) ;
+            
+        if (not (_rx_streamer_active.count(chan) and _rx_streamer_active.at(chan))) {
+            UHD_RFNOC_BLOCK_TRACE()
+                << "replay_block_ctrl_impl::issue_stream_cmd() called on inactive "
+                   "channel. Skipping.";
+            return;
+        }
+        
+        constexpr size_t max_num_samps = 0x0fffffff;
+        if (stream_cmd.num_samps > max_num_samps) {
+            UHD_LOG_ERROR("REPLAY",
+                "Requesting too many samples in a single burst! "
+                "Requested " + std::to_string(stream_cmd.num_samps) + ", maximum "
+                "is " + std::to_string(max_num_samps) + ".");
+            throw uhd::value_error("Requested too many samples in a single burst.");
+        }
+        
+        // Setup the mode to instruction flags
+        typedef std::tuple<bool, bool, bool, bool> inst_t;
+        static const std::map<stream_cmd_t::stream_mode_t, inst_t> mode_to_inst {
+                                                               // reload, chain, samps, stop
+            {stream_cmd_t::STREAM_MODE_START_CONTINUOUS,   inst_t(true,   true,  false, false)},
+            {stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS,    inst_t(false,  false, false, true)},
+            {stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE, inst_t(false,  false, true,  false)},
+            {stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_MORE, inst_t(false,  true,  true,  false)}
+        };
+        
+        // Setup the instruction flag values
+        bool inst_reload, inst_chain, inst_samps, inst_stop;
+        std::tie(inst_reload, inst_chain, inst_samps, inst_stop) =
+            mode_to_inst.at(stream_cmd.stream_mode);
+            
+        // Calculate how many words to transfer at a time in CONTINUOUS mode
+        uint32_t cont_burst_size =
+            (_params[chan].play_buffer_size > WORDS_PER_PACKET) ? 
+            WORDS_PER_PACKET : _params[chan].play_buffer_size;
+            
+        // Calculate the number of words to transfer in NUM_SAMPS mode
+        uint32_t num_words = stream_cmd.num_samps / SAMPLES_PER_WORD;
+        
+        // Calculate the word from flags and length
+        const uint32_t cmd_word = 0
+            | (uint32_t(stream_cmd.stream_now ? 1 : 0) << 31)
+            | (uint32_t(inst_chain            ? 1 : 0) << 30)
+            | (uint32_t(inst_reload           ? 1 : 0) << 29)
+            | (uint32_t(inst_stop             ? 1 : 0) << 28)
+            | (inst_samps ? num_words : (inst_stop ? 0 : cont_burst_size));
+        
+        // Issue the stream command
+        sr_write("RX_CTRL_COMMAND", cmd_word, chan);
+    }
+    
+private:
+    struct replay_params_t {
+        size_t words_per_packet;
+        uint32_t rec_base_addr;
+        uint32_t rec_buffer_size;
+        uint32_t play_base_addr;
+        uint32_t play_buffer_size;
+    };
+    
+    size_t _num_channels;
+    std::vector<replay_params_t> _params;
+    
+    std::mutex _mutex;
+};
+
+UHD_RFNOC_BLOCK_REGISTER(replay_block_ctrl, "Replay");