| USRP Hardware Driver and USRP Manual Version: 4.8.0.makepkg-0-g308126a4 UHD and USRP Manual |

Loading...
Searching...
No Matches
mock_block.hpp
Go to the documentation of this file.
1//
2// Copyright 2019 Ettus Research, a National Instruments Brand
3//
4// SPDX-License-Identifier: GPL-3.0-or-later
5//
6
7#pragma once
8
9#include <uhd/config.hpp>
10#include <uhd/property_tree.hpp>
11#include <uhd/rfnoc/defaults.hpp>
12#include <uhd/rfnoc/mb_controller.hpp>
13#include <uhd/rfnoc/noc_block_base.hpp>
14#include <uhd/rfnoc/register_iface.hpp>
15#include <uhd/types/time_spec.hpp>
16#include <uhd/utils/log.hpp>
17#include <unordered_map>
18#include <boost/format.hpp>
19#include <vector>
20
21 namespace uhd { namespace rfnoc {
22
27 class UHD_API mock_reg_iface_t : public register_iface
28{
29 public:
30 mock_reg_iface_t() = default;
31 ~mock_reg_iface_t() override = default;
32
33 /**************************************************************************
34 * API
35 *************************************************************************/
36 void poke32(uint32_t addr, uint32_t data, uhd::time_spec_t time, bool ack) override
37 {
38 write_memory[addr] = data;
39 _poke_cb(addr, data, time, ack);
40 }
41
42 void multi_poke32(const std::vector<uint32_t> addrs,
43 const std::vector<uint32_t> data,
44 uhd::time_spec_t time,
45 bool ack) override
46 {
47 if (addrs.size() != data.size()) {
48 throw uhd::value_error("addrs and data vectors must be of the same length");
49 }
50 for (size_t i = 0; i < addrs.size(); i++) {
51 poke32(addrs[i], data[i], time, ack);
52 }
53 }
54
55 void block_poke32(uint32_t first_addr,
56 const std::vector<uint32_t> data,
57 uhd::time_spec_t timestamp,
58 bool ack) override
59 {
60 for (size_t i = 0; i < data.size(); i++) {
61 poke32(first_addr + 4 * i, data[i], timestamp, ack);
62 }
63 }
64
65 uint32_t peek32(uint32_t addr, uhd::time_spec_t time) override
66 {
67 _peek_cb(addr, time);
68 try {
69 return read_memory.at(addr);
70 } catch (const std::out_of_range&) {
71 throw uhd::runtime_error(
72 str(boost::format("No data defined for address: 0x%04X") % addr));
73 }
74 }
75
76 std::vector<uint32_t> block_peek32(
77 uint32_t first_addr, size_t length, uhd::time_spec_t time) override
78 {
79 std::vector<uint32_t> result(length, 0);
80 for (size_t i = 0; i < length; ++i) {
81 result[i] = peek32(first_addr + i * 4, time);
82 }
83 return result;
84 }
85
86 void poll32(uint32_t addr,
87 uint32_t data,
88 uint32_t mask,
89 uhd::time_spec_t /* timeout */,
90 uhd::time_spec_t time = uhd::time_spec_t::ASAP,
91 bool /* ack */ = false) override
92 {
93 if (force_timeout) {
94 throw uhd::op_timeout("timeout");
95 }
96
97 if ((peek32(addr, time) & mask) == data) {
98 UHD_LOG_INFO("MOCK_REG_IFACE", "poll32() successful at addr " << addr);
99 } else {
100 UHD_LOG_INFO("MOCK_REG_IFACE", "poll32() not successful at addr " << addr);
101 }
102 }
103
104 void sleep(uhd::time_spec_t /*duration*/, bool /*ack*/) override
105 {
106 // nop
107 }
108
109 void register_async_msg_validator(async_msg_validator_t /*callback_f*/) override
110 {
111 // nop
112 }
113
114 void register_async_msg_handler(async_msg_callback_t /*callback_f*/) override
115 {
116 // nop
117 }
118
119 void set_policy(const std::string& name, const uhd::device_addr_t& args) override
120 {
121 UHD_LOG_INFO("MOCK_REG_IFACE",
122 "Requested to set policy for " << name << " to " << args.to_string());
123 }
124
125 uint16_t get_src_epid() const override
126 {
127 return 0;
128 }
129
130 uint16_t get_port_num() const override
131 {
132 return 0;
133 }
134
135 void define_custom_register_space(const uint32_t /*start_addr*/,
136 const uint32_t /*length*/,
137 std::function<void(uint32_t, uint32_t)> /*poke_fn*/,
138 std::function<uint32_t(uint32_t)> /*peek_fn*/) override
139 {
140 // nop
141 }
142
143 bool force_timeout = false;
144
146 std::unordered_map<uint32_t, uint32_t> read_memory;
148 // been previously set.
149 std::unordered_map<uint32_t, uint32_t> write_memory;
150
151 protected:
152 virtual void _poke_cb(
153 uint32_t /*addr*/, uint32_t /*data*/, uhd::time_spec_t /*time*/, bool /*ack*/)
154 {
155 }
156
157 virtual void _peek_cb(uint32_t /*addr*/, uhd::time_spec_t /*time*/) {}
158};
159
162 struct UHD_API mock_block_container
163{
164 friend class get_mock_block;
166 std::shared_ptr<mock_reg_iface_t> reg_iface;
167
169 uhd::property_tree::sptr tree;
170
172 // the register space is appropiately primed before doing so.
173 template <typename block_type = noc_block_base>
174 std::shared_ptr<block_type> get_block()
175 {
176 return std::dynamic_pointer_cast<block_type>(factory(std::move(make_args)));
177 }
178
180 std::function<noc_block_base::sptr(noc_block_base::make_args_ptr)> factory;
181
182 // Note: The make args would ideally be captured by the factory function,
183 // but std::functions need to be CopyConstructible, and this struct doesn't,
184 // so it needs to live out here in the open.
185 noc_block_base::make_args_ptr make_args;
186};
187
190 UHD_API mock_block_container get_mock_block(const noc_id_t noc_id,
191 const size_t num_inputs = 1,
192 const size_t num_outputs = 1,
193 const uhd::device_addr_t& args = uhd::device_addr_t(),
194 const size_t mtu = 8000,
195 const device_type_t device_id = ANY_DEVICE,
196 std::shared_ptr<mock_reg_iface_t> client_reg_iface = nullptr,
197 mb_controller::sptr mbc = nullptr);
198
199}}; // namespace uhd::rfnoc
uhd::device_addr_t
Definition device_addr.hpp:39
uhd::device_addr_t::to_string
std::string to_string(void) const
uhd::property_tree::sptr
std::shared_ptr< property_tree > sptr
Definition property_tree.hpp:224
uhd::rfnoc::mb_controller::sptr
std::shared_ptr< mb_controller > sptr
Definition mb_controller.hpp:33
uhd::rfnoc::mock_reg_iface_t::mock_reg_iface_t
mock_reg_iface_t()=default
uhd::rfnoc::mock_reg_iface_t::get_src_epid
uint16_t get_src_epid() const override
Definition mock_block.hpp:125
uhd::rfnoc::mock_reg_iface_t::~mock_reg_iface_t
~mock_reg_iface_t() override=default
uhd::rfnoc::mock_reg_iface_t::write_memory
std::unordered_map< uint32_t, uint32_t > write_memory
All peeks read from this map. A peek will fail if the address has not.
Definition mock_block.hpp:149
uhd::rfnoc::mock_reg_iface_t::block_poke32
void block_poke32(uint32_t first_addr, const std::vector< uint32_t > data, uhd::time_spec_t timestamp, bool ack) override
Definition mock_block.hpp:55
uhd::rfnoc::mock_reg_iface_t::block_peek32
std::vector< uint32_t > block_peek32(uint32_t first_addr, size_t length, uhd::time_spec_t time) override
Definition mock_block.hpp:76
uhd::rfnoc::mock_reg_iface_t::poll32
void poll32(uint32_t addr, uint32_t data, uint32_t mask, uhd::time_spec_t, uhd::time_spec_t time=uhd::time_spec_t::ASAP, bool=false) override
Definition mock_block.hpp:86
uhd::rfnoc::mock_reg_iface_t::multi_poke32
void multi_poke32(const std::vector< uint32_t > addrs, const std::vector< uint32_t > data, uhd::time_spec_t time, bool ack) override
Definition mock_block.hpp:42
uhd::rfnoc::mock_reg_iface_t::peek32
uint32_t peek32(uint32_t addr, uhd::time_spec_t time) override
Definition mock_block.hpp:65
uhd::rfnoc::mock_reg_iface_t::_peek_cb
virtual void _peek_cb(uint32_t, uhd::time_spec_t)
Definition mock_block.hpp:157
uhd::rfnoc::mock_reg_iface_t::set_policy
void set_policy(const std::string &name, const uhd::device_addr_t &args) override
Definition mock_block.hpp:119
uhd::rfnoc::mock_reg_iface_t::force_timeout
bool force_timeout
Definition mock_block.hpp:143
uhd::rfnoc::mock_reg_iface_t::read_memory
std::unordered_map< uint32_t, uint32_t > read_memory
All pokes end up writing to this map.
Definition mock_block.hpp:146
uhd::rfnoc::mock_reg_iface_t::register_async_msg_validator
void register_async_msg_validator(async_msg_validator_t) override
Definition mock_block.hpp:109
uhd::rfnoc::mock_reg_iface_t::define_custom_register_space
void define_custom_register_space(const uint32_t, const uint32_t, std::function< void(uint32_t, uint32_t)>, std::function< uint32_t(uint32_t)>) override
Definition mock_block.hpp:135
uhd::rfnoc::mock_reg_iface_t::sleep
void sleep(uhd::time_spec_t, bool) override
Definition mock_block.hpp:104
uhd::rfnoc::mock_reg_iface_t::_poke_cb
virtual void _poke_cb(uint32_t, uint32_t, uhd::time_spec_t, bool)
Definition mock_block.hpp:152
uhd::rfnoc::mock_reg_iface_t::poke32
void poke32(uint32_t addr, uint32_t data, uhd::time_spec_t time, bool ack) override
Definition mock_block.hpp:36
uhd::rfnoc::mock_reg_iface_t::register_async_msg_handler
void register_async_msg_handler(async_msg_callback_t) override
Definition mock_block.hpp:114
uhd::rfnoc::mock_reg_iface_t::get_port_num
uint16_t get_port_num() const override
Definition mock_block.hpp:130
uhd::rfnoc::noc_block_base::make_args_ptr
std::unique_ptr< make_args_t > make_args_ptr
Opaque pointer to the constructor arguments.
Definition noc_block_base.hpp:54
uhd::rfnoc::noc_block_base::sptr
std::shared_ptr< noc_block_base > sptr
Definition noc_block_base.hpp:48
uhd::rfnoc::register_iface
Definition register_iface.hpp:39
uhd::rfnoc::register_iface::async_msg_callback_t
std::function< void( uint32_t addr, const std::vector< uint32_t > &data, boost::optional< uint64_t >)> async_msg_callback_t
Definition register_iface.hpp:66
uhd::rfnoc::register_iface::async_msg_validator_t
std::function< bool(uint32_t addr, const std::vector< uint32_t > &data)> async_msg_validator_t
Definition register_iface.hpp:53
uhd::time_spec_t
Definition time_spec.hpp:31
uhd::time_spec_t::ASAP
static constexpr double ASAP
Definition time_spec.hpp:34
UHD_API
#define UHD_API
Definition config.h:87
config.hpp
defaults.hpp
UHD_LOG_INFO
#define UHD_LOG_INFO(component,...)
Definition log.h:53
log.hpp
mb_controller.hpp
uhd::rfnoc
Definition actions.hpp:24
uhd::rfnoc::device_type_t
uint16_t device_type_t
Device Type.
Definition defaults.hpp:56
uhd::rfnoc::noc_id_t
uint32_t noc_id_t
Definition defaults.hpp:52
uhd::rfnoc::get_mock_block
UHD_API mock_block_container get_mock_block(const noc_id_t noc_id, const size_t num_inputs=1, const size_t num_outputs=1, const uhd::device_addr_t &args=uhd::device_addr_t(), const size_t mtu=8000, const device_type_t device_id=ANY_DEVICE, std::shared_ptr< mock_reg_iface_t > client_reg_iface=nullptr, mb_controller::sptr mbc=nullptr)
uhd
Definition build_info.hpp:12
noc_block_base.hpp
property_tree.hpp
register_iface.hpp
uhd::op_timeout
Definition exception.hpp:252
uhd::rfnoc::mock_block_container
Definition mock_block.hpp:163
uhd::rfnoc::mock_block_container::tree
uhd::property_tree::sptr tree
Reference to the prop tree object the block sees.
Definition mock_block.hpp:169
uhd::rfnoc::mock_block_container::get_block
std::shared_ptr< block_type > get_block()
Use this to retrieve a reference to the block controller. Make sure that.
Definition mock_block.hpp:174
uhd::rfnoc::mock_block_container::factory
std::function< noc_block_base::sptr(noc_block_base::make_args_ptr)> factory
Factory to get the block. Use get_block() instead.
Definition mock_block.hpp:180
uhd::rfnoc::mock_block_container::reg_iface
std::shared_ptr< mock_reg_iface_t > reg_iface
Reference to the register interface object.
Definition mock_block.hpp:166
uhd::rfnoc::mock_block_container::make_args
noc_block_base::make_args_ptr make_args
Definition mock_block.hpp:185
uhd::rfnoc::mock_block_container::get_mock_block
friend class get_mock_block
Definition mock_block.hpp:164
uhd::runtime_error
Definition exception.hpp:133
uhd::value_error
Definition exception.hpp:109
time_spec.hpp