diff options
Diffstat (limited to 'host/lib/rfnoc/legacy_compat.cpp')
| -rw-r--r-- | host/lib/rfnoc/legacy_compat.cpp | 874 |
1 files changed, 490 insertions, 384 deletions
diff --git a/host/lib/rfnoc/legacy_compat.cpp b/host/lib/rfnoc/legacy_compat.cpp index c5bd7891a..f794b1c5a 100644 --- a/host/lib/rfnoc/legacy_compat.cpp +++ b/host/lib/rfnoc/legacy_compat.cpp @@ -7,26 +7,26 @@ #include "../usrp/device3/device3_impl.hpp" #include <uhd/property_tree.hpp> -#include <uhd/rfnoc/radio_ctrl.hpp> #include <uhd/rfnoc/ddc_block_ctrl.hpp> #include <uhd/rfnoc/graph.hpp> -#include <uhd/usrp/subdev_spec.hpp> +#include <uhd/rfnoc/radio_ctrl.hpp> #include <uhd/stream.hpp> -#include <uhd/types/stream_cmd.hpp> +#include <uhd/transport/chdr.hpp> #include <uhd/types/direction.hpp> #include <uhd/types/ranges.hpp> -#include <uhd/utils/log.hpp> -#include <uhd/transport/chdr.hpp> +#include <uhd/types/stream_cmd.hpp> #include <uhd/usrp/multi_usrp.hpp> +#include <uhd/usrp/subdev_spec.hpp> +#include <uhd/utils/log.hpp> #include <uhdlib/rfnoc/legacy_compat.hpp> #include <boost/make_shared.hpp> #define UHD_LEGACY_LOG() UHD_LOGGER_TRACE("RFNOC") using namespace uhd::rfnoc; -using uhd::usrp::subdev_spec_t; -using uhd::usrp::subdev_spec_pair_t; using uhd::stream_cmd_t; +using uhd::usrp::subdev_spec_pair_t; +using uhd::usrp::subdev_spec_t; /************************************************************************ * Constants and globals @@ -34,24 +34,18 @@ using uhd::stream_cmd_t; static const std::string RADIO_BLOCK_NAME = "Radio"; static const std::string DFIFO_BLOCK_NAME = "DmaFIFO"; static const std::string SFIFO_BLOCK_NAME = "FIFO"; -static const std::string DDC_BLOCK_NAME = "DDC"; -static const std::string DUC_BLOCK_NAME = "DUC"; +static const std::string DDC_BLOCK_NAME = "DDC"; +static const std::string DUC_BLOCK_NAME = "DUC"; static const size_t MAX_BYTES_PER_HEADER = - uhd::transport::vrt::chdr::max_if_hdr_words64 * sizeof(uint64_t); + uhd::transport::vrt::chdr::max_if_hdr_words64 * sizeof(uint64_t); static const size_t BYTES_PER_SAMPLE = 4; // We currently only support sc16 static boost::mutex _make_mutex; -static const std::vector<std::string> - LEGACY_BLOCKS_LIST = - { - RADIO_BLOCK_NAME, - DFIFO_BLOCK_NAME, - SFIFO_BLOCK_NAME, - DDC_BLOCK_NAME, - DUC_BLOCK_NAME - }; +static const std::vector<std::string> LEGACY_BLOCKS_LIST = { + RADIO_BLOCK_NAME, DFIFO_BLOCK_NAME, SFIFO_BLOCK_NAME, DDC_BLOCK_NAME, DUC_BLOCK_NAME}; typedef std::vector<source_block_ctrl_base::sptr> source_block_list_t; typedef std::vector<sink_block_ctrl_base::sptr> sink_block_list_t; -typedef std::map<std::string, std::pair<source_block_list_t, sink_block_list_t>> block_name_to_block_map_t; +typedef std::map<std::string, std::pair<source_block_list_t, sink_block_list_t>> + block_name_to_block_map_t; typedef std::pair<source_block_ctrl_base::sptr, size_t> source_port_t; typedef std::pair<sink_block_ctrl_base::sptr, size_t> sink_port_t; /************************************************************************ @@ -62,46 +56,42 @@ static uhd::fs_path mb_root(const size_t mboard) return uhd::fs_path("/mboards") / mboard; } -size_t num_ports(const uhd::property_tree::sptr &tree, const std::string &block_name, const std::string &in_out) +size_t num_ports(const uhd::property_tree::sptr& tree, + const std::string& block_name, + const std::string& in_out) { - return tree->list( - uhd::fs_path("/mboards/0/xbar") / - str(boost::format("%s_0") % block_name) / - "ports" / in_out - ).size(); + return tree + ->list(uhd::fs_path("/mboards/0/xbar") / str(boost::format("%s_0") % block_name) + / "ports" / in_out) + .size(); } -size_t calc_num_tx_chans_per_radio( - const uhd::property_tree::sptr &tree, +size_t calc_num_tx_chans_per_radio(const uhd::property_tree::sptr& tree, const size_t num_radios_per_board, const bool has_ducs, - const bool has_dmafifo -) { + const bool has_dmafifo) +{ const size_t num_radio_ports = num_ports(tree, RADIO_BLOCK_NAME, "in"); if (has_ducs) { - return std::min( - num_radio_ports, - num_ports(tree, DUC_BLOCK_NAME, "in") - ); + return std::min(num_radio_ports, num_ports(tree, DUC_BLOCK_NAME, "in")); } if (not has_dmafifo) { return num_radio_ports; } - const size_t num_dmafifo_ports_per_radio = num_ports(tree, DFIFO_BLOCK_NAME, "in") / num_radios_per_board; + const size_t num_dmafifo_ports_per_radio = + num_ports(tree, DFIFO_BLOCK_NAME, "in") / num_radios_per_board; UHD_ASSERT_THROW(num_dmafifo_ports_per_radio); - return std::min( - num_radio_ports, - num_dmafifo_ports_per_radio - ); + return std::min(num_radio_ports, num_dmafifo_ports_per_radio); } /*! Recreate passed property without bound subscribers. Maintains current property value. -*/ + */ template <typename T> -static void recreate_property(const uhd::fs_path &path, uhd::property_tree::sptr &tree) { +static void recreate_property(const uhd::fs_path& path, uhd::property_tree::sptr& tree) +{ T temp = tree->access<T>(path).get(); tree->remove(path); tree->create<T>(path).set(temp); @@ -116,95 +106,110 @@ public: /************************************************************************ * Structors and Initialization ***********************************************************************/ - legacy_compat_impl( - uhd::device3::sptr device, - const uhd::device_addr_t &args - ) : _device(device), - _tree(device->get_tree()), - _has_ducs(not args.has_key("skip_duc") and not device->find_blocks(DUC_BLOCK_NAME).empty()), - _has_ddcs(not args.has_key("skip_ddc") and not device->find_blocks(DDC_BLOCK_NAME).empty()), - _has_dmafifo(not args.has_key("skip_dram") and not device->find_blocks(DFIFO_BLOCK_NAME).empty()), - _has_sramfifo(not args.has_key("skip_sram") and not device->find_blocks(SFIFO_BLOCK_NAME).empty()), - _num_mboards(_tree->list("/mboards").size()), - _num_radios_per_board(device->find_blocks<radio_ctrl>("0/Radio").size()), // These might throw, maybe we catch that and provide a nicer error message. - _num_tx_chans_per_radio( - calc_num_tx_chans_per_radio(_tree, _num_radios_per_board, _has_ducs, _has_dmafifo) - ), - _num_rx_chans_per_radio(_has_ddcs ? - std::min(num_ports(_tree, RADIO_BLOCK_NAME, "out"), num_ports(_tree, DDC_BLOCK_NAME, "out")) - : num_ports(_tree, RADIO_BLOCK_NAME, "out")), - _rx_spp(get_block_ctrl<radio_ctrl>(0, RADIO_BLOCK_NAME, 0)->get_arg<int>("spp")), - _tx_spp(_rx_spp), - _rx_channel_map(_num_mboards, std::vector<radio_port_pair_t>()), - _tx_channel_map(_num_mboards, std::vector<radio_port_pair_t>()) + legacy_compat_impl(uhd::device3::sptr device, const uhd::device_addr_t& args) + : _device(device) + , _tree(device->get_tree()) + , _has_ducs(not args.has_key("skip_duc") + and not device->find_blocks(DUC_BLOCK_NAME).empty()) + , _has_ddcs(not args.has_key("skip_ddc") + and not device->find_blocks(DDC_BLOCK_NAME).empty()) + , _has_dmafifo(not args.has_key("skip_dram") + and not device->find_blocks(DFIFO_BLOCK_NAME).empty()) + , _has_sramfifo(not args.has_key("skip_sram") + and not device->find_blocks(SFIFO_BLOCK_NAME).empty()) + , _num_mboards(_tree->list("/mboards").size()) + , _num_radios_per_board(device->find_blocks<radio_ctrl>("0/Radio").size()) + , // These might throw, maybe we catch that and provide a nicer error message. + _num_tx_chans_per_radio(calc_num_tx_chans_per_radio( + _tree, _num_radios_per_board, _has_ducs, _has_dmafifo)) + , _num_rx_chans_per_radio( + _has_ddcs ? std::min(num_ports(_tree, RADIO_BLOCK_NAME, "out"), + num_ports(_tree, DDC_BLOCK_NAME, "out")) + : num_ports(_tree, RADIO_BLOCK_NAME, "out")) + , _rx_spp(get_block_ctrl<radio_ctrl>(0, RADIO_BLOCK_NAME, 0)->get_arg<int>("spp")) + , _tx_spp(_rx_spp) + , _rx_channel_map(_num_mboards, std::vector<radio_port_pair_t>()) + , _tx_channel_map(_num_mboards, std::vector<radio_port_pair_t>()) { _device->clear(); check_available_periphs(); // Throws if invalid configuration. setup_prop_tree(); if (_tree->exists("/mboards/0/mtu/send")) { - _tx_spp = (_tree->access<size_t>("/mboards/0/mtu/send").get() - MAX_BYTES_PER_HEADER) / BYTES_PER_SAMPLE; + _tx_spp = (_tree->access<size_t>("/mboards/0/mtu/send").get() + - MAX_BYTES_PER_HEADER) + / BYTES_PER_SAMPLE; } connect_blocks(); if (args.has_key("skip_ddc")) { - UHD_LEGACY_LOG() << "[legacy_compat] Skipping DDCs by user request." ; + UHD_LEGACY_LOG() << "[legacy_compat] Skipping DDCs by user request."; } else if (not _has_ddcs) { UHD_LOGGER_WARNING("RFNOC") - << "[legacy_compat] No DDCs detected. You will only be able to receive at the radio frontend rate." - ; + << "[legacy_compat] No DDCs detected. You will only be able to receive " + "at the radio frontend rate."; } if (args.has_key("skip_duc")) { - UHD_LEGACY_LOG() << "[legacy_compat] Skipping DUCs by user request." ; + UHD_LEGACY_LOG() << "[legacy_compat] Skipping DUCs by user request."; } else if (not _has_ducs) { - UHD_LOGGER_WARNING("RFNOC") << "[legacy_compat] No DUCs detected. You will only be able to transmit at the radio frontend rate." ; + UHD_LOGGER_WARNING("RFNOC") + << "[legacy_compat] No DUCs detected. You will only be able to transmit " + "at the radio frontend rate."; } if (args.has_key("skip_dram")) { - UHD_LEGACY_LOG() << "[legacy_compat] Skipping DRAM by user request." ; + UHD_LEGACY_LOG() << "[legacy_compat] Skipping DRAM by user request."; } if (args.has_key("skip_sram")) { UHD_LEGACY_LOG() << "[legacy_compat] Skipping SRAM by user request."; } if (not _has_dmafifo and not _has_sramfifo) { - UHD_LOGGER_WARNING("RFNOC") << "[legacy_compat] No FIFO detected. Higher transmit rates may encounter errors."; + UHD_LOGGER_WARNING("RFNOC") << "[legacy_compat] No FIFO detected. Higher " + "transmit rates may encounter errors."; } for (size_t mboard = 0; mboard < _num_mboards; mboard++) { for (size_t radio = 0; radio < _num_radios_per_board; radio++) { - auto radio_block_ctrl = get_block_ctrl<radio_ctrl>(mboard, "Radio", radio); + auto radio_block_ctrl = + get_block_ctrl<radio_ctrl>(mboard, "Radio", radio); for (size_t port = 0; port < _num_rx_chans_per_radio; port++) { - if (!radio_block_ctrl->get_dboard_fe_from_chan(port, uhd::RX_DIRECTION).empty()) { + if (!radio_block_ctrl->get_dboard_fe_from_chan( + port, uhd::RX_DIRECTION) + .empty()) { _rx_channel_map[mboard].push_back({radio, port}); - } + } } for (size_t port = 0; port < _num_tx_chans_per_radio; port++) { - if (!radio_block_ctrl->get_dboard_fe_from_chan(port, uhd::TX_DIRECTION).empty()) { + if (!radio_block_ctrl->get_dboard_fe_from_chan( + port, uhd::TX_DIRECTION) + .empty()) { _tx_channel_map[mboard].push_back({radio, port}); } } } - const double tick_rate = _tree->access<double>(mb_root(mboard) / "tick_rate").get(); + const double tick_rate = + _tree->access<double>(mb_root(mboard) / "tick_rate").get(); update_tick_rate_on_blocks(tick_rate, mboard); } } ~legacy_compat_impl() { - remove_prop_subscribers(); + remove_prop_subscribers(); } /************************************************************************ * API Calls ***********************************************************************/ - inline uhd::fs_path rx_dsp_root(const size_t mboard_idx, const size_t dsp_index, const size_t port_index) + inline uhd::fs_path rx_dsp_root( + const size_t mboard_idx, const size_t dsp_index, const size_t port_index) { - return mb_root(mboard_idx) / "xbar" / - str(boost::format("%s_%d") % DDC_BLOCK_NAME % dsp_index) / - "legacy_api" / port_index; + return mb_root(mboard_idx) / "xbar" + / str(boost::format("%s_%d") % DDC_BLOCK_NAME % dsp_index) / "legacy_api" + / port_index; } uhd::fs_path rx_dsp_root(const size_t mboard_idx, const size_t chan) { // The DSP index is the same as the radio index - size_t dsp_index = _rx_channel_map[mboard_idx][chan].radio_index; + size_t dsp_index = _rx_channel_map[mboard_idx][chan].radio_index; size_t port_index = _rx_channel_map[mboard_idx][chan].port_index; if (not _has_ddcs) { @@ -214,17 +219,18 @@ public: return rx_dsp_root(mboard_idx, dsp_index, port_index); } - inline uhd::fs_path tx_dsp_root(const size_t mboard_idx, const size_t dsp_index, const size_t port_index) + inline uhd::fs_path tx_dsp_root( + const size_t mboard_idx, const size_t dsp_index, const size_t port_index) { - return mb_root(mboard_idx) / "xbar" / - str(boost::format("%s_%d") % DUC_BLOCK_NAME % dsp_index) / - "legacy_api" / port_index; + return mb_root(mboard_idx) / "xbar" + / str(boost::format("%s_%d") % DUC_BLOCK_NAME % dsp_index) / "legacy_api" + / port_index; } uhd::fs_path tx_dsp_root(const size_t mboard_idx, const size_t chan) { // The DSP index is the same as the radio index - size_t dsp_index = _tx_channel_map[mboard_idx][chan].radio_index; + size_t dsp_index = _tx_channel_map[mboard_idx][chan].radio_index; size_t port_index = _tx_channel_map[mboard_idx][chan].port_index; if (not _has_ducs) { @@ -237,33 +243,31 @@ public: uhd::fs_path rx_fe_root(const size_t mboard_idx, const size_t chan) { size_t radio_index = _rx_channel_map[mboard_idx][chan].radio_index; - size_t port_index = _rx_channel_map[mboard_idx][chan].port_index; - return uhd::fs_path(str( - boost::format("/mboards/%d/xbar/%s_%d/rx_fe_corrections/%d/") - % mboard_idx % RADIO_BLOCK_NAME % radio_index % port_index - )); + size_t port_index = _rx_channel_map[mboard_idx][chan].port_index; + return uhd::fs_path( + str(boost::format("/mboards/%d/xbar/%s_%d/rx_fe_corrections/%d/") % mboard_idx + % RADIO_BLOCK_NAME % radio_index % port_index)); } uhd::fs_path tx_fe_root(const size_t mboard_idx, const size_t chan) { size_t radio_index = _tx_channel_map[mboard_idx][chan].radio_index; - size_t port_index = _tx_channel_map[mboard_idx][chan].port_index; - return uhd::fs_path(str( - boost::format("/mboards/%d/xbar/%s_%d/tx_fe_corrections/%d/") - % mboard_idx % RADIO_BLOCK_NAME % radio_index % port_index - )); + size_t port_index = _tx_channel_map[mboard_idx][chan].port_index; + return uhd::fs_path( + str(boost::format("/mboards/%d/xbar/%s_%d/tx_fe_corrections/%d/") % mboard_idx + % RADIO_BLOCK_NAME % radio_index % port_index)); } //! Get all legacy blocks from the LEGACY_BLOCK_LIST return in a form of // {BLOCK_NAME: <{source_block_pointer},{sink_block_pointer}>} block_name_to_block_map_t get_legacy_blocks(uhd::device3::sptr _device) { - block_name_to_block_map_t result ; - for(auto each_block_name: LEGACY_BLOCKS_LIST){ + block_name_to_block_map_t result; + for (auto each_block_name : LEGACY_BLOCKS_LIST) { std::vector<block_id_t> block_list = _device->find_blocks(each_block_name); std::pair<source_block_list_t, sink_block_list_t> ss_pair; source_block_list_t src_list; sink_block_list_t snk_list; - for(auto each_block: block_list){ + for (auto each_block : block_list) { uhd::rfnoc::source_block_ctrl_base::sptr src = _device->get_block_ctrl<source_block_ctrl_base>(each_block); src_list.push_back(src); @@ -271,78 +275,82 @@ public: _device->get_block_ctrl<sink_block_ctrl_base>(each_block); snk_list.push_back(snk); } - ss_pair = std::make_pair(src_list, snk_list); + ss_pair = std::make_pair(src_list, snk_list); result[each_block_name] = ss_pair; } return result; } - void issue_stream_cmd(const stream_cmd_t &stream_cmd, size_t mboard, size_t chan) + void issue_stream_cmd(const stream_cmd_t& stream_cmd, size_t mboard, size_t chan) { - UHD_LEGACY_LOG() << "[legacy_compat] issue_stream_cmd() " ; - const size_t &radio_index = _rx_channel_map[mboard][chan].radio_index; - const size_t &port_index = _rx_channel_map[mboard][chan].port_index; + UHD_LEGACY_LOG() << "[legacy_compat] issue_stream_cmd() "; + const size_t& radio_index = _rx_channel_map[mboard][chan].radio_index; + const size_t& port_index = _rx_channel_map[mboard][chan].port_index; if (_has_ddcs) { - get_block_ctrl<ddc_block_ctrl>(mboard, DDC_BLOCK_NAME, radio_index)->issue_stream_cmd(stream_cmd, port_index); + get_block_ctrl<ddc_block_ctrl>(mboard, DDC_BLOCK_NAME, radio_index) + ->issue_stream_cmd(stream_cmd, port_index); } else { - get_block_ctrl<radio_ctrl>(mboard, RADIO_BLOCK_NAME, radio_index)->issue_stream_cmd(stream_cmd, port_index); + get_block_ctrl<radio_ctrl>(mboard, RADIO_BLOCK_NAME, radio_index) + ->issue_stream_cmd(stream_cmd, port_index); } } - //! Sets block_id<N> and block_port<N> in the streamer args, otherwise forwards the call - uhd::rx_streamer::sptr get_rx_stream(const uhd::stream_args_t &args_) + //! Sets block_id<N> and block_port<N> in the streamer args, otherwise forwards the + //! call + uhd::rx_streamer::sptr get_rx_stream(const uhd::stream_args_t& args_) { uhd::stream_args_t args(args_); if (args.otw_format.empty()) { args.otw_format = "sc16"; } _update_stream_args_for_streaming<uhd::RX_DIRECTION>(args, _rx_channel_map); - UHD_LEGACY_LOG() << "[legacy_compat] rx stream args: " << args.args.to_string() ; + UHD_LEGACY_LOG() << "[legacy_compat] rx stream args: " << args.args.to_string(); uhd::rx_streamer::sptr streamer = _device->get_rx_stream(args); - for(const size_t chan: args.channels) { + for (const size_t chan : args.channels) { _rx_stream_cache[chan] = streamer; } return streamer; } - //! Sets block_id<N> and block_port<N> in the streamer args, otherwise forwards the call. - // If spp is in the args, update the radios. If it's not set, copy the value from the radios. - uhd::tx_streamer::sptr get_tx_stream(const uhd::stream_args_t &args_) + //! Sets block_id<N> and block_port<N> in the streamer args, otherwise forwards the + //! call. + // If spp is in the args, update the radios. If it's not set, copy the value from the + // radios. + uhd::tx_streamer::sptr get_tx_stream(const uhd::stream_args_t& args_) { uhd::stream_args_t args(args_); if (args.otw_format.empty()) { args.otw_format = "sc16"; } _update_stream_args_for_streaming<uhd::TX_DIRECTION>(args, _tx_channel_map); - UHD_LEGACY_LOG() << "[legacy_compat] tx stream args: " << args.args.to_string() ; + UHD_LEGACY_LOG() << "[legacy_compat] tx stream args: " << args.args.to_string(); uhd::tx_streamer::sptr streamer = _device->get_tx_stream(args); - for(const size_t chan: args.channels) { + for (const size_t chan : args.channels) { _tx_stream_cache[chan] = streamer; } return streamer; } - double get_tick_rate(const size_t mboard_idx=0) + double get_tick_rate(const size_t mboard_idx = 0) { return _tree->access<double>(mb_root(mboard_idx) / "tick_rate").get(); } - uhd::meta_range_t lambda_get_samp_rate_range( - const size_t mboard_idx, - const size_t radio_idx, - const size_t chan, - uhd::direction_t dir - ) { - radio_ctrl::sptr radio_sptr = get_block_ctrl<radio_ctrl>(mboard_idx, RADIO_BLOCK_NAME, radio_idx); - const double samp_rate = (dir == uhd::TX_DIRECTION) ? - radio_sptr->get_input_samp_rate(chan) : - radio_sptr->get_output_samp_rate(chan) - ; + uhd::meta_range_t lambda_get_samp_rate_range(const size_t mboard_idx, + const size_t radio_idx, + const size_t chan, + uhd::direction_t dir) + { + radio_ctrl::sptr radio_sptr = + get_block_ctrl<radio_ctrl>(mboard_idx, RADIO_BLOCK_NAME, radio_idx); + const double samp_rate = (dir == uhd::TX_DIRECTION) + ? radio_sptr->get_input_samp_rate(chan) + : radio_sptr->get_output_samp_rate(chan); return uhd::meta_range_t(samp_rate, samp_rate, 0.0); } - void set_tick_rate(const double tick_rate, const size_t mboard_idx=0) + void set_tick_rate(const double tick_rate, const size_t mboard_idx = 0) { _tree->access<double>(mb_root(mboard_idx) / "tick_rate").set(tick_rate); update_tick_rate_on_blocks(tick_rate, mboard_idx); @@ -356,13 +364,18 @@ public: // Set DDC values: if (chan == uhd::usrp::multi_usrp::ALL_CHANS) { - for (size_t mboard_idx = 0; mboard_idx < _rx_channel_map.size(); mboard_idx++) { - for (size_t chan_idx = 0; chan_idx < _rx_channel_map[mboard_idx].size(); chan_idx++) { - const size_t dsp_index = _rx_channel_map[mboard_idx][chan_idx].radio_index; - const size_t port_index = _rx_channel_map[mboard_idx][chan_idx].port_index; - _tree->access<double>(rx_dsp_root(mboard_idx, dsp_index, port_index) / "rate/value") - .set(rate) - ; + for (size_t mboard_idx = 0; mboard_idx < _rx_channel_map.size(); + mboard_idx++) { + for (size_t chan_idx = 0; chan_idx < _rx_channel_map[mboard_idx].size(); + chan_idx++) { + const size_t dsp_index = + _rx_channel_map[mboard_idx][chan_idx].radio_index; + const size_t port_index = + _rx_channel_map[mboard_idx][chan_idx].port_index; + _tree + ->access<double>( + rx_dsp_root(mboard_idx, dsp_index, port_index) / "rate/value") + .set(rate); } } } else { @@ -370,25 +383,29 @@ public: if (_rx_stream_cache.count(chan)) { uhd::rx_streamer::sptr str_ptr = _rx_stream_cache[chan].lock(); if (str_ptr) { - for(const rx_stream_map_type::value_type &chan_streamer_pair: _rx_stream_cache) { + for (const rx_stream_map_type::value_type& chan_streamer_pair : + _rx_stream_cache) { if (chan_streamer_pair.second.lock() == str_ptr) { chans_to_change.insert(chan_streamer_pair.first); } } } } - for(const size_t this_chan: chans_to_change) { + for (const size_t this_chan : chans_to_change) { size_t mboard, mb_chan; - chan_to_mcp<uhd::RX_DIRECTION>(this_chan, _rx_channel_map, mboard, mb_chan); + chan_to_mcp<uhd::RX_DIRECTION>( + this_chan, _rx_channel_map, mboard, mb_chan); const size_t dsp_index = _rx_channel_map[mboard][mb_chan].radio_index; const size_t port_index = _rx_channel_map[mboard][mb_chan].port_index; - _tree->access<double>(rx_dsp_root(mboard, dsp_index, port_index) / "rate/value") - .set(rate) - ; + _tree + ->access<double>( + rx_dsp_root(mboard, dsp_index, port_index) / "rate/value") + .set(rate); } } // Update streamers: - boost::dynamic_pointer_cast<uhd::usrp::device3_impl>(_device)->update_rx_streamers(rate); + boost::dynamic_pointer_cast<uhd::usrp::device3_impl>(_device) + ->update_rx_streamers(rate); } void set_tx_rate(const double rate, const size_t chan) @@ -399,13 +416,18 @@ public: // Set DUC values: if (chan == uhd::usrp::multi_usrp::ALL_CHANS) { - for (size_t mboard_idx = 0; mboard_idx < _tx_channel_map.size(); mboard_idx++) { - for (size_t chan_idx = 0; chan_idx < _tx_channel_map[mboard_idx].size(); chan_idx++) { - const size_t dsp_index = _tx_channel_map[mboard_idx][chan_idx].radio_index; - const size_t port_index = _tx_channel_map[mboard_idx][chan_idx].port_index; - _tree->access<double>(tx_dsp_root(mboard_idx, dsp_index, port_index) / "rate/value") - .set(rate) - ; + for (size_t mboard_idx = 0; mboard_idx < _tx_channel_map.size(); + mboard_idx++) { + for (size_t chan_idx = 0; chan_idx < _tx_channel_map[mboard_idx].size(); + chan_idx++) { + const size_t dsp_index = + _tx_channel_map[mboard_idx][chan_idx].radio_index; + const size_t port_index = + _tx_channel_map[mboard_idx][chan_idx].port_index; + _tree + ->access<double>( + tx_dsp_root(mboard_idx, dsp_index, port_index) / "rate/value") + .set(rate); } } } else { @@ -413,37 +435,45 @@ public: if (_tx_stream_cache.count(chan)) { uhd::tx_streamer::sptr str_ptr = _tx_stream_cache[chan].lock(); if (str_ptr) { - for(const tx_stream_map_type::value_type &chan_streamer_pair: _tx_stream_cache) { + for (const tx_stream_map_type::value_type& chan_streamer_pair : + _tx_stream_cache) { if (chan_streamer_pair.second.lock() == str_ptr) { chans_to_change.insert(chan_streamer_pair.first); } } } } - for(const size_t this_chan: chans_to_change) { + for (const size_t this_chan : chans_to_change) { size_t mboard, mb_chan; - chan_to_mcp<uhd::TX_DIRECTION>(this_chan, _tx_channel_map, mboard, mb_chan); + chan_to_mcp<uhd::TX_DIRECTION>( + this_chan, _tx_channel_map, mboard, mb_chan); const size_t dsp_index = _tx_channel_map[mboard][mb_chan].radio_index; const size_t port_index = _tx_channel_map[mboard][mb_chan].port_index; - _tree->access<double>(tx_dsp_root(mboard, dsp_index, port_index) / "rate/value") - .set(rate) - ; + _tree + ->access<double>( + tx_dsp_root(mboard, dsp_index, port_index) / "rate/value") + .set(rate); } } // Update streamers: - boost::dynamic_pointer_cast<uhd::usrp::device3_impl>(_device)->update_tx_streamers(rate); + boost::dynamic_pointer_cast<uhd::usrp::device3_impl>(_device) + ->update_tx_streamers(rate); } private: // types - struct radio_port_pair_t { - radio_port_pair_t(const size_t radio=0, const size_t port=0) : radio_index(radio), port_index(port) {} + struct radio_port_pair_t + { + radio_port_pair_t(const size_t radio = 0, const size_t port = 0) + : radio_index(radio), port_index(port) + { + } size_t radio_index; size_t port_index; }; //! Map: _rx_channel_map[mboard_idx][chan_idx] => (Radio, Port) // Container is not a std::map because we need to guarantee contiguous // ports and correct order anyway. - typedef std::vector< std::vector<radio_port_pair_t> > chan_map_t; + typedef std::vector<std::vector<radio_port_pair_t>> chan_map_t; private: // methods /************************************************************************ @@ -451,71 +481,70 @@ private: // methods ***********************************************************************/ std::string get_slot_name(const size_t radio_index) { - if (radio_index == 0){ + if (radio_index == 0) { return "A"; - }else if (radio_index == 1){ + } else if (radio_index == 1) { return "B"; - }else if (radio_index == 2){ + } else if (radio_index == 2) { return "C"; - }else if (radio_index == 3){ + } else if (radio_index == 3) { return "D"; - }else{ + } else { throw uhd::index_error(str( boost::format("[legacy_compat]: radio index %u out of supported range.") - % radio_index - )); + % radio_index)); } } size_t get_radio_index(const std::string slot_name) { - if (slot_name == "A"){ + if (slot_name == "A") { return 0; - }else if (slot_name == "B"){ + } else if (slot_name == "B") { return 1; - }else if (slot_name == "C"){ + } else if (slot_name == "C") { return 2; - }else if (slot_name == "D"){ - return 3; - }else { - throw uhd::key_error(str( - boost::format("[legacy_compat]: radio slot name %s out of supported range.") - % slot_name - )); + } else if (slot_name == "D") { + return 3; + } else { + throw uhd::key_error( + str(boost::format( + "[legacy_compat]: radio slot name %s out of supported range.") + % slot_name)); } } template <typename block_type> - inline typename block_type::sptr get_block_ctrl(const size_t mboard_idx, const std::string &name, const size_t block_count) + inline typename block_type::sptr get_block_ctrl( + const size_t mboard_idx, const std::string& name, const size_t block_count) { block_id_t block_id(mboard_idx, name, block_count); return _device->get_block_ctrl<block_type>(block_id); } template <uhd::direction_t dir> - inline void chan_to_mcp( - const size_t chan, const chan_map_t &chan_map, - size_t &mboard_idx, size_t &mb_chan_idx - ) { - mboard_idx = 0; + inline void chan_to_mcp(const size_t chan, + const chan_map_t& chan_map, + size_t& mboard_idx, + size_t& mb_chan_idx) + { + mboard_idx = 0; mb_chan_idx = chan; while (mb_chan_idx >= chan_map[mboard_idx].size()) { - mb_chan_idx -= chan_map[mboard_idx++].size(); + mb_chan_idx -= chan_map[mboard_idx++].size(); } if (mboard_idx >= chan_map.size()) { - throw uhd::index_error(str( - boost::format("[legacy_compat]: %s channel %u out of range for given frontend configuration.") - % (dir == uhd::TX_DIRECTION ? "TX" : "RX") - % chan - )); + throw uhd::index_error( + str(boost::format("[legacy_compat]: %s channel %u out of range for given " + "frontend configuration.") + % (dir == uhd::TX_DIRECTION ? "TX" : "RX") % chan)); } } template <uhd::direction_t dir> void _update_stream_args_for_streaming( - uhd::stream_args_t &args, - const chan_map_t &chan_map - ) { + uhd::stream_args_t& args, const chan_map_t& chan_map) + { // If the user provides spp, that value is always applied. If it's // different from what we thought it was, we need to update the blocks. // If it's not provided, we provide our own spp value. @@ -528,17 +557,20 @@ private: // methods } else { for (size_t mboard = 0; mboard < _num_mboards; mboard++) { for (size_t radio = 0; radio < _num_radios_per_board; radio++) { - const size_t this_spp = get_block_ctrl<radio_ctrl>(mboard, RADIO_BLOCK_NAME, radio)->get_arg<int>("spp"); + const size_t this_spp = + get_block_ctrl<radio_ctrl>(mboard, RADIO_BLOCK_NAME, radio) + ->get_arg<int>("spp"); target_spp = std::min(this_spp, target_spp); } } } for (size_t mboard = 0; mboard < _num_mboards; mboard++) { for (size_t radio = 0; radio < _num_radios_per_board; radio++) { - get_block_ctrl<radio_ctrl>(mboard, RADIO_BLOCK_NAME, radio)->set_arg<int>("spp", target_spp); + get_block_ctrl<radio_ctrl>(mboard, RADIO_BLOCK_NAME, radio) + ->set_arg<int>("spp", target_spp); } } - _rx_spp = target_spp; + _rx_spp = target_spp; args.args["spp"] = str(boost::format("%d") % _rx_spp); } else { if (args.args.has_key("spp") and args_spp != _tx_spp) { @@ -556,81 +588,107 @@ private: // methods const size_t stream_arg_chan_idx = args.channels[i]; // Determine which mboard, and on that mboard, which channel this is: size_t mboard_idx, this_mboard_chan_idx; - chan_to_mcp<dir>(stream_arg_chan_idx, chan_map, mboard_idx, this_mboard_chan_idx); + chan_to_mcp<dir>( + stream_arg_chan_idx, chan_map, mboard_idx, this_mboard_chan_idx); // Map that mboard and channel to a block: - const size_t radio_index = chan_map[mboard_idx][this_mboard_chan_idx].radio_index; + const size_t radio_index = + chan_map[mboard_idx][this_mboard_chan_idx].radio_index; size_t port_index = chan_map[mboard_idx][this_mboard_chan_idx].port_index; - auto block_and_port = _get_streamer_block_id_and_port<dir>(mboard_idx, radio_index, port_index); + auto block_and_port = + _get_streamer_block_id_and_port<dir>(mboard_idx, radio_index, port_index); auto block_name = block_and_port.first.to_string(); - port_index = block_and_port.second; - args.args[str(boost::format("block_id%d") % stream_arg_chan_idx)] = block_name; - args.args[str(boost::format("block_port%d") % stream_arg_chan_idx)] = str(boost::format("%d") % port_index); + port_index = block_and_port.second; + args.args[str(boost::format("block_id%d") % stream_arg_chan_idx)] = + block_name; + args.args[str(boost::format("block_port%d") % stream_arg_chan_idx)] = + str(boost::format("%d") % port_index); // Map radio to channel (for in-band response) - args.args[str(boost::format("radio_id%d") % stream_arg_chan_idx)] = block_id_t(mboard_idx, RADIO_BLOCK_NAME, radio_index).to_string(); - args.args[str(boost::format("radio_port%d") % stream_arg_chan_idx)] = str(boost::format("%d") % chan_map[mboard_idx][this_mboard_chan_idx].port_index); + args.args[str(boost::format("radio_id%d") % stream_arg_chan_idx)] = + block_id_t(mboard_idx, RADIO_BLOCK_NAME, radio_index).to_string(); + args.args[str(boost::format("radio_port%d") % stream_arg_chan_idx)] = + str(boost::format("%d") + % chan_map[mboard_idx][this_mboard_chan_idx].port_index); } } //! Given mboard_index(m), radio_index(r), and port_index(p), - // this function returns the index of a block on the input block list that match m,r,p + // this function returns the index of a block on the input block list that match + // m,r,p template <typename T> - size_t find_block(const std::vector<T> &port_list, const size_t &m, const size_t &r, const size_t &p) + size_t find_block(const std::vector<T>& port_list, + const size_t& m, + const size_t& r, + const size_t& p) { - size_t index = 0; - for (auto port : port_list) - { + size_t index = 0; + for (auto port : port_list) { auto block_id = (port.first)->get_block_id(); - if (p == port.second && r == block_id.get_block_count() && m == block_id.get_device_no()) - { + if (p == port.second && r == block_id.get_block_count() + && m == block_id.get_device_no()) { return index; } index++; } - throw uhd::runtime_error((boost::format("Could not find block in list for device %d, radio %d, and port %d") % m % r % p).str()); + throw uhd::runtime_error( + (boost::format( + "Could not find block in list for device %d, radio %d, and port %d") + % m % r % p) + .str()); } template <uhd::direction_t dir> std::pair<block_id_t, size_t> _get_streamer_block_id_and_port( - const size_t &mboard_idx, - const size_t &radio_index, - const size_t &port_index) + const size_t& mboard_idx, const size_t& radio_index, const size_t& port_index) { block_name_to_block_map_t legacy_block_map = get_legacy_blocks(_device); - if (dir == uhd::TX_DIRECTION){ - auto radio_snk_flat = _flatten_blocks_by_n_ports(legacy_block_map[RADIO_BLOCK_NAME].second); - size_t index_snk = find_block<sink_port_t>(radio_snk_flat, mboard_idx, radio_index, port_index); - if (_has_sramfifo){ - auto sfifo_snk_flat = _flatten_blocks_by_n_ports(legacy_block_map[SFIFO_BLOCK_NAME].second); + if (dir == uhd::TX_DIRECTION) { + auto radio_snk_flat = + _flatten_blocks_by_n_ports(legacy_block_map[RADIO_BLOCK_NAME].second); + size_t index_snk = find_block<sink_port_t>( + radio_snk_flat, mboard_idx, radio_index, port_index); + if (_has_sramfifo) { + auto sfifo_snk_flat = + _flatten_blocks_by_n_ports(legacy_block_map[SFIFO_BLOCK_NAME].second); UHD_ASSERT_THROW(index_snk < sfifo_snk_flat.size()); auto sfifo_block = sfifo_snk_flat[index_snk].first->get_block_id(); return std::make_pair(sfifo_block, sfifo_snk_flat[index_snk].second); - }else if (_has_dmafifo){ - auto dfifo_snk_flat = _flatten_blocks_by_n_ports(legacy_block_map[DFIFO_BLOCK_NAME].second); + } else if (_has_dmafifo) { + auto dfifo_snk_flat = + _flatten_blocks_by_n_ports(legacy_block_map[DFIFO_BLOCK_NAME].second); UHD_ASSERT_THROW(index_snk < dfifo_snk_flat.size()); auto dfifo_block = dfifo_snk_flat[index_snk].first->get_block_id(); return std::make_pair(dfifo_block, dfifo_snk_flat[index_snk].second); - }else{ - if (_has_ducs){ - return std::make_pair(block_id_t(mboard_idx, DUC_BLOCK_NAME, radio_index).to_string(),port_index); - auto duc_snk_flat = _flatten_blocks_by_n_ports(legacy_block_map[DUC_BLOCK_NAME].second); + } else { + if (_has_ducs) { + return std::make_pair( + block_id_t(mboard_idx, DUC_BLOCK_NAME, radio_index).to_string(), + port_index); + auto duc_snk_flat = _flatten_blocks_by_n_ports( + legacy_block_map[DUC_BLOCK_NAME].second); UHD_ASSERT_THROW(index_snk < duc_snk_flat.size()); auto duc_block = duc_snk_flat[index_snk].first->get_block_id(); return std::make_pair(duc_block, duc_snk_flat[index_snk].second); - }else{ - return std::make_pair(block_id_t(mboard_idx, RADIO_BLOCK_NAME, radio_index).to_string(),port_index); + } else { + return std::make_pair( + block_id_t(mboard_idx, RADIO_BLOCK_NAME, radio_index).to_string(), + port_index); } } - }else{ - auto radio_src_flat = _flatten_blocks_by_n_ports(legacy_block_map[RADIO_BLOCK_NAME].first); - size_t index_src = find_block<source_port_t>(radio_src_flat, mboard_idx, radio_index, port_index); - if (_has_ddcs){ - auto ddc_src_flat = _flatten_blocks_by_n_ports(legacy_block_map[DDC_BLOCK_NAME].first); + } else { + auto radio_src_flat = + _flatten_blocks_by_n_ports(legacy_block_map[RADIO_BLOCK_NAME].first); + size_t index_src = find_block<source_port_t>( + radio_src_flat, mboard_idx, radio_index, port_index); + if (_has_ddcs) { + auto ddc_src_flat = + _flatten_blocks_by_n_ports(legacy_block_map[DDC_BLOCK_NAME].first); UHD_ASSERT_THROW(index_src < ddc_src_flat.size()); auto ddc_block = ddc_src_flat[index_src].first->get_block_id(); return std::make_pair(ddc_block, ddc_src_flat[index_src].second); - } - else{ - return std::make_pair(block_id_t(mboard_idx, RADIO_BLOCK_NAME, radio_index).to_string(),port_index); + } else { + return std::make_pair( + block_id_t(mboard_idx, RADIO_BLOCK_NAME, radio_index).to_string(), + port_index); } } } @@ -649,7 +707,8 @@ private: // methods void check_available_periphs() { if (_num_radios_per_board == 0) { - throw uhd::runtime_error("For legacy APIs, all devices require at least one radio."); + throw uhd::runtime_error( + "For legacy APIs, all devices require at least one radio."); } block_id_t radio_block_id(0, RADIO_BLOCK_NAME); block_id_t duc_block_id(0, DUC_BLOCK_NAME); @@ -668,17 +727,20 @@ private: // methods if (not _device->has_block(radio_block_id) or (_has_ducs and not _device->has_block(duc_block_id)) or (_has_ddcs and not _device->has_block(ddc_block_id)) - or (_has_dmafifo and not _device->has_block(fifo_block_id)) - ) { - throw uhd::runtime_error("For legacy APIs, all devices require the same number of radios, DDCs and DUCs."); + or (_has_dmafifo and not _device->has_block(fifo_block_id))) { + throw uhd::runtime_error("For legacy APIs, all devices require the " + "same number of radios, DDCs and DUCs."); } - const size_t this_spp = get_block_ctrl<radio_ctrl>(i, RADIO_BLOCK_NAME, k)->get_arg<int>("spp"); + const size_t this_spp = get_block_ctrl<radio_ctrl>(i, RADIO_BLOCK_NAME, k) + ->get_arg<int>("spp"); if (this_spp != _rx_spp) { UHD_LOGGER_WARNING("RFNOC") << str( - boost::format("[legacy compat] Radios have differing spp values: %s has %d, others have %d. UHD will use smaller spp value for all connections. Performance might be not optimal.") - % radio_block_id.to_string() % this_spp % _rx_spp - ); + boost::format( + "[legacy compat] Radios have differing spp values: %s has " + "%d, others have %d. UHD will use smaller spp value for all " + "connections. Performance might be not optimal.") + % radio_block_id.to_string() % this_spp % _rx_spp); } } } @@ -693,89 +755,111 @@ private: // methods // Subdev specs if (_tree->exists(root / "tx_subdev_spec")) { _tree->access<subdev_spec_t>(root / "tx_subdev_spec") - .add_coerced_subscriber(boost::bind(&legacy_compat_impl::set_subdev_spec, this, _1, mboard_idx, uhd::TX_DIRECTION)) + .add_coerced_subscriber( + boost::bind(&legacy_compat_impl::set_subdev_spec, + this, + _1, + mboard_idx, + uhd::TX_DIRECTION)) .update() - .set_publisher(boost::bind(&legacy_compat_impl::get_subdev_spec, this, mboard_idx, uhd::TX_DIRECTION)); + .set_publisher(boost::bind(&legacy_compat_impl::get_subdev_spec, + this, + mboard_idx, + uhd::TX_DIRECTION)); } else { _tree->create<subdev_spec_t>(root / "tx_subdev_spec") - .add_coerced_subscriber(boost::bind(&legacy_compat_impl::set_subdev_spec, this, _1, mboard_idx, uhd::TX_DIRECTION)) - .set_publisher(boost::bind(&legacy_compat_impl::get_subdev_spec, this, mboard_idx, uhd::TX_DIRECTION)); + .add_coerced_subscriber( + boost::bind(&legacy_compat_impl::set_subdev_spec, + this, + _1, + mboard_idx, + uhd::TX_DIRECTION)) + .set_publisher(boost::bind(&legacy_compat_impl::get_subdev_spec, + this, + mboard_idx, + uhd::TX_DIRECTION)); } if (_tree->exists(root / "rx_subdev_spec")) { _tree->access<subdev_spec_t>(root / "rx_subdev_spec") - .add_coerced_subscriber(boost::bind(&legacy_compat_impl::set_subdev_spec, this, _1, mboard_idx, uhd::RX_DIRECTION)) + .add_coerced_subscriber( + boost::bind(&legacy_compat_impl::set_subdev_spec, + this, + _1, + mboard_idx, + uhd::RX_DIRECTION)) .update() - .set_publisher(boost::bind(&legacy_compat_impl::get_subdev_spec, this, mboard_idx, uhd::RX_DIRECTION)); + .set_publisher(boost::bind(&legacy_compat_impl::get_subdev_spec, + this, + mboard_idx, + uhd::RX_DIRECTION)); } else { - _tree->create<subdev_spec_t>(root / "rx_subdev_spec") - .add_coerced_subscriber(boost::bind(&legacy_compat_impl::set_subdev_spec, this, _1, mboard_idx, uhd::RX_DIRECTION)) - .set_publisher(boost::bind(&legacy_compat_impl::get_subdev_spec, this, mboard_idx, uhd::RX_DIRECTION)); + _tree->create<subdev_spec_t>(root / "rx_subdev_spec") + .add_coerced_subscriber( + boost::bind(&legacy_compat_impl::set_subdev_spec, + this, + _1, + mboard_idx, + uhd::RX_DIRECTION)) + .set_publisher(boost::bind(&legacy_compat_impl::get_subdev_spec, + this, + mboard_idx, + uhd::RX_DIRECTION)); } if (not _has_ddcs) { - for (size_t radio_idx = 0; radio_idx < _num_radios_per_board; radio_idx++) { + for (size_t radio_idx = 0; radio_idx < _num_radios_per_board; + radio_idx++) { for (size_t chan = 0; chan < _num_rx_chans_per_radio; chan++) { - const uhd::fs_path rx_dsp_base_path(mb_root(mboard_idx) / "rx_dsps" / radio_idx / chan); + const uhd::fs_path rx_dsp_base_path( + mb_root(mboard_idx) / "rx_dsps" / radio_idx / chan); _tree->create<double>(rx_dsp_base_path / "rate/value") .set(0.0) - .set_publisher( - boost::bind( - &radio_ctrl::get_output_samp_rate, - get_block_ctrl<radio_ctrl>(mboard_idx, RADIO_BLOCK_NAME, radio_idx), - chan - ) - ) - ; + .set_publisher(boost::bind(&radio_ctrl::get_output_samp_rate, + get_block_ctrl<radio_ctrl>( + mboard_idx, RADIO_BLOCK_NAME, radio_idx), + chan)); _tree->create<uhd::meta_range_t>(rx_dsp_base_path / "rate/range") - .set_publisher( - boost::bind( - &legacy_compat_impl::lambda_get_samp_rate_range, - this, - mboard_idx, radio_idx, chan, - uhd::RX_DIRECTION - ) - ) - ; + .set_publisher(boost::bind( + &legacy_compat_impl::lambda_get_samp_rate_range, + this, + mboard_idx, + radio_idx, + chan, + uhd::RX_DIRECTION)); _tree->create<double>(rx_dsp_base_path / "freq/value") - .set_publisher([](){ return 0.0; }) - ; + .set_publisher([]() { return 0.0; }); _tree->create<uhd::meta_range_t>(rx_dsp_base_path / "freq/range") - .set_publisher([](){ return uhd::meta_range_t(0.0, 0.0, 0.0); }) - ; + .set_publisher( + []() { return uhd::meta_range_t(0.0, 0.0, 0.0); }); } } } /* if not _has_ddcs */ if (not _has_ducs) { - for (size_t radio_idx = 0; radio_idx < _num_radios_per_board; radio_idx++) { + for (size_t radio_idx = 0; radio_idx < _num_radios_per_board; + radio_idx++) { for (size_t chan = 0; chan < _num_tx_chans_per_radio; chan++) { - const uhd::fs_path tx_dsp_base_path(mb_root(mboard_idx) / "tx_dsps" / radio_idx / chan); + const uhd::fs_path tx_dsp_base_path( + mb_root(mboard_idx) / "tx_dsps" / radio_idx / chan); _tree->create<double>(tx_dsp_base_path / "rate/value") .set(0.0) - .set_publisher( - boost::bind( - &radio_ctrl::get_output_samp_rate, - get_block_ctrl<radio_ctrl>(mboard_idx, RADIO_BLOCK_NAME, radio_idx), - chan - ) - ) - ; + .set_publisher(boost::bind(&radio_ctrl::get_output_samp_rate, + get_block_ctrl<radio_ctrl>( + mboard_idx, RADIO_BLOCK_NAME, radio_idx), + chan)); _tree->create<uhd::meta_range_t>(tx_dsp_base_path / "rate/range") - .set_publisher( - boost::bind( - &legacy_compat_impl::lambda_get_samp_rate_range, - this, - mboard_idx, radio_idx, chan, - uhd::TX_DIRECTION - ) - ) - ; + .set_publisher(boost::bind( + &legacy_compat_impl::lambda_get_samp_rate_range, + this, + mboard_idx, + radio_idx, + chan, + uhd::TX_DIRECTION)); _tree->create<double>(tx_dsp_base_path / "freq/value") - .set_publisher([](){ return 0.0; }) - ; + .set_publisher([]() { return 0.0; }); _tree->create<uhd::meta_range_t>(tx_dsp_base_path / "freq/range") - .set_publisher([](){ return uhd::meta_range_t(0.0, 0.0, 0.0); }) - ; + .set_publisher( + []() { return uhd::meta_range_t(0.0, 0.0, 0.0); }); } } } /* if not _has_ducs */ @@ -791,11 +875,11 @@ private: // methods uhd::fs_path root = mb_root(mboard_idx); // Subdev specs if (_tree->exists(root / "tx_subdev_spec")) { - recreate_property<subdev_spec_t>(root / "tx_subdev_spec", _tree); + recreate_property<subdev_spec_t>(root / "tx_subdev_spec", _tree); } if (_tree->exists(root / "rx_subdev_spec")) { - recreate_property<subdev_spec_t>(root / "rx_subdev_spec", _tree); + recreate_property<subdev_spec_t>(root / "rx_subdev_spec", _tree); } } } @@ -805,24 +889,22 @@ private: // methods std::vector<source_port_t> _flatten_blocks_by_n_ports(source_block_list_t block_list) { std::vector<source_port_t> result; - for (auto block: block_list ){ - for(auto port: block->get_output_ports()){ - - result.push_back(std::make_pair(block,port)); + for (auto block : block_list) { + for (auto port : block->get_output_ports()) { + result.push_back(std::make_pair(block, port)); } } - //assign to block prior ports + // assign to block prior ports size_t port = 0; - size_t i = 0; - for (size_t j=0; j<result.size(); j++){ - auto block = block_list[j%block_list.size()]; + size_t i = 0; + for (size_t j = 0; j < result.size(); j++) { + auto block = block_list[j % block_list.size()]; UHD_ASSERT_THROW(port < block->get_output_ports().size()); - if (i == block_list.size()) - { + if (i == block_list.size()) { i = 0; - port ++; + port++; } - result[j] = std::make_pair(block,port); + result[j] = std::make_pair(block, port); i++; } return result; @@ -834,23 +916,22 @@ private: // methods std::vector<sink_port_t> _flatten_blocks_by_n_ports(sink_block_list_t block_list) { std::vector<sink_port_t> result; - for (auto block: block_list ){ - for(auto port: block->get_input_ports()){ - result.push_back(std::make_pair(block,port)); + for (auto block : block_list) { + for (auto port : block->get_input_ports()) { + result.push_back(std::make_pair(block, port)); } } - //assign to block prior ports + // assign to block prior ports size_t port = 0; - size_t i = 0; - for (size_t j=0; j<result.size(); j++){ - auto block = block_list[j%block_list.size()]; + size_t i = 0; + for (size_t j = 0; j < result.size(); j++) { + auto block = block_list[j % block_list.size()]; UHD_ASSERT_THROW(port < block->get_input_ports().size()); - if (i == block_list.size()) - { + if (i == block_list.size()) { i = 0; - port ++; + port++; } - result[j] = std::make_pair(block,port); + result[j] = std::make_pair(block, port); i++; } return result; @@ -872,34 +953,41 @@ private: // methods */ void connect_blocks() { - _graph = _device->create_graph("legacy"); + _graph = _device->create_graph("legacy"); const size_t rx_bpp = _rx_spp * BYTES_PER_SAMPLE + MAX_BYTES_PER_HEADER; const size_t tx_bpp = _tx_spp * BYTES_PER_SAMPLE + MAX_BYTES_PER_HEADER; - block_name_to_block_map_t legacy_block_map = get_legacy_blocks(_device); + block_name_to_block_map_t legacy_block_map = get_legacy_blocks(_device); size_t index = 0, sram_fifo_index = 0, dma_fifo_index = 0; - auto ddc_snk_flat = _flatten_blocks_by_n_ports(legacy_block_map[DDC_BLOCK_NAME].second); - auto duc_src_flat = _flatten_blocks_by_n_ports(legacy_block_map[DUC_BLOCK_NAME].first); - auto duc_snk_flat = _flatten_blocks_by_n_ports(legacy_block_map[DUC_BLOCK_NAME].second); - auto radio_src_flat = _flatten_blocks_by_n_ports(legacy_block_map[RADIO_BLOCK_NAME].first); - auto radio_snk_flat = _flatten_blocks_by_n_ports(legacy_block_map[RADIO_BLOCK_NAME].second); - auto sfifo_src_flat = _flatten_blocks_by_n_ports(legacy_block_map[SFIFO_BLOCK_NAME].first); - auto dfifo_src_flat = _flatten_blocks_by_n_ports(legacy_block_map[DFIFO_BLOCK_NAME].first); - for(auto each_src_radio_block:radio_src_flat){ + auto ddc_snk_flat = + _flatten_blocks_by_n_ports(legacy_block_map[DDC_BLOCK_NAME].second); + auto duc_src_flat = + _flatten_blocks_by_n_ports(legacy_block_map[DUC_BLOCK_NAME].first); + auto duc_snk_flat = + _flatten_blocks_by_n_ports(legacy_block_map[DUC_BLOCK_NAME].second); + auto radio_src_flat = + _flatten_blocks_by_n_ports(legacy_block_map[RADIO_BLOCK_NAME].first); + auto radio_snk_flat = + _flatten_blocks_by_n_ports(legacy_block_map[RADIO_BLOCK_NAME].second); + auto sfifo_src_flat = + _flatten_blocks_by_n_ports(legacy_block_map[SFIFO_BLOCK_NAME].first); + auto dfifo_src_flat = + _flatten_blocks_by_n_ports(legacy_block_map[DFIFO_BLOCK_NAME].first); + for (auto each_src_radio_block : radio_src_flat) { auto radio_block = each_src_radio_block.first->get_block_id(); if (_has_ddcs) { UHD_ASSERT_THROW(index < ddc_snk_flat.size()); auto ddc_block = ddc_snk_flat[index].first->get_block_id(); - _graph->connect( - radio_block, each_src_radio_block.second, - ddc_block, ddc_snk_flat[index].second, - rx_bpp - ); + _graph->connect(radio_block, + each_src_radio_block.second, + ddc_block, + ddc_snk_flat[index].second, + rx_bpp); } index++; } index = 0; - for(auto each_snk_radio_block:radio_snk_flat){ - auto radio_block = each_snk_radio_block.first->get_block_id(); + for (auto each_snk_radio_block : radio_snk_flat) { + auto radio_block = each_snk_radio_block.first->get_block_id(); auto down_stream_block = radio_block; auto down_stream_port = each_snk_radio_block.second; if (_has_ducs) { @@ -907,36 +995,41 @@ private: // methods UHD_ASSERT_THROW(index < duc_src_flat.size()); auto duc_snk_block = duc_snk_flat[index].first->get_block_id(); auto duc_src_block = duc_src_flat[index].first->get_block_id(); - _graph->connect( - duc_src_block, duc_src_flat[index].second, - radio_block, each_snk_radio_block.second, + _graph->connect(duc_src_block, + duc_src_flat[index].second, + radio_block, + each_snk_radio_block.second, rx_bpp); down_stream_block = duc_snk_block; - down_stream_port = duc_snk_flat[index].second; + down_stream_port = duc_snk_flat[index].second; } if (_has_sramfifo) { - if(sram_fifo_index < sfifo_src_flat.size()){ - auto sfifo_block = sfifo_src_flat[sram_fifo_index].first->get_block_id(); - _graph->connect( - sfifo_block, sfifo_src_flat[sram_fifo_index].second, - down_stream_block, down_stream_port, - tx_bpp - ); + if (sram_fifo_index < sfifo_src_flat.size()) { + auto sfifo_block = + sfifo_src_flat[sram_fifo_index].first->get_block_id(); + _graph->connect(sfifo_block, + sfifo_src_flat[sram_fifo_index].second, + down_stream_block, + down_stream_port, + tx_bpp); sram_fifo_index++; - }else { - UHD_LOGGER_WARNING("RFNOC") << "[legacy compat] Running out of SRAM FIFO ports to connect."; + } else { + UHD_LOGGER_WARNING("RFNOC") + << "[legacy compat] Running out of SRAM FIFO ports to connect."; } - }else if (_has_dmafifo) { - if(dma_fifo_index < dfifo_src_flat.size()){ - auto dfifo_block = dfifo_src_flat[dma_fifo_index].first->get_block_id(); - _graph->connect( - dfifo_block, dfifo_src_flat[dma_fifo_index].second, - down_stream_block, down_stream_port, - tx_bpp - ); + } else if (_has_dmafifo) { + if (dma_fifo_index < dfifo_src_flat.size()) { + auto dfifo_block = + dfifo_src_flat[dma_fifo_index].first->get_block_id(); + _graph->connect(dfifo_block, + dfifo_src_flat[dma_fifo_index].second, + down_stream_block, + down_stream_port, + tx_bpp); dma_fifo_index++; - }else { - UHD_LOGGER_WARNING("RFNOC") << "[legacy compat] Running out of DRAM FIFO ports to connect."; + } else { + UHD_LOGGER_WARNING("RFNOC") + << "[legacy compat] Running out of DRAM FIFO ports to connect."; } } index++; @@ -953,18 +1046,25 @@ private: // methods * Then we map to ((0, 0), (1, 0)). I.e., zero-th port on radio 0 and * radio 1, respectively. */ - void set_subdev_spec(const subdev_spec_t &spec, const size_t mboard, const uhd::direction_t dir) + void set_subdev_spec( + const subdev_spec_t& spec, const size_t mboard, const uhd::direction_t dir) { UHD_ASSERT_THROW(mboard < _num_mboards); - chan_map_t &chan_map = (dir == uhd::TX_DIRECTION) ? _tx_channel_map : _rx_channel_map; + chan_map_t& chan_map = (dir == uhd::TX_DIRECTION) ? _tx_channel_map + : _rx_channel_map; std::vector<radio_port_pair_t> new_mapping(spec.size()); for (size_t i = 0; i < spec.size(); i++) { const size_t new_radio_index = get_radio_index(spec[i].db_name); - radio_ctrl::sptr radio = get_block_ctrl<radio_ctrl>(mboard, "Radio", new_radio_index); + radio_ctrl::sptr radio = + get_block_ctrl<radio_ctrl>(mboard, "Radio", new_radio_index); size_t new_port_index = radio->get_chan_from_dboard_fe(spec[i].sd_name, dir); - auto port_size = (dir == uhd::TX_DIRECTION) ? radio->get_input_ports().size() :radio->get_output_ports().size(); - auto default_index = (dir == uhd::TX_DIRECTION)? radio->get_input_ports().at(0) : radio->get_output_ports().at(0); + auto port_size = (dir == uhd::TX_DIRECTION) + ? radio->get_input_ports().size() + : radio->get_output_ports().size(); + auto default_index = (dir == uhd::TX_DIRECTION) + ? radio->get_input_ports().at(0) + : radio->get_output_ports().at(0); if (new_port_index >= port_size) { new_port_index = default_index; } @@ -979,13 +1079,15 @@ private: // methods { UHD_ASSERT_THROW(mboard < _num_mboards); subdev_spec_t subdev_spec; - chan_map_t &chan_map = (dir == uhd::TX_DIRECTION) ? _tx_channel_map : _rx_channel_map; + chan_map_t& chan_map = (dir == uhd::TX_DIRECTION) ? _tx_channel_map + : _rx_channel_map; for (size_t chan_idx = 0; chan_idx < chan_map[mboard].size(); chan_idx++) { - const size_t radio_index = chan_map[mboard][chan_idx].radio_index; - const size_t port_index = chan_map[mboard][chan_idx].port_index; + const size_t radio_index = chan_map[mboard][chan_idx].radio_index; + const size_t port_index = chan_map[mboard][chan_idx].port_index; const std::string new_db_name = get_slot_name(radio_index); const std::string new_sd_name = - get_block_ctrl<radio_ctrl>(mboard, "Radio", radio_index)->get_dboard_fe_from_chan(port_index, dir); + get_block_ctrl<radio_ctrl>(mboard, "Radio", radio_index) + ->get_dboard_fe_from_chan(port_index, dir); subdev_spec_pair_t new_pair(new_db_name, new_sd_name); subdev_spec.push_back(new_pair); } @@ -1003,15 +1105,18 @@ private: // methods radio_block_id.set_block_count(radio); duc_block_id.set_block_count(radio); ddc_block_id.set_block_count(radio); - radio_ctrl::sptr radio_sptr = _device->get_block_ctrl<radio_ctrl>(radio_block_id); + radio_ctrl::sptr radio_sptr = + _device->get_block_ctrl<radio_ctrl>(radio_block_id); radio_sptr->set_rate(tick_rate); for (size_t chan = 0; chan < _num_rx_chans_per_radio and _has_ddcs; chan++) { const double radio_output_rate = radio_sptr->get_output_samp_rate(chan); - _device->get_block_ctrl(ddc_block_id)->set_arg<double>("input_rate", radio_output_rate, chan); + _device->get_block_ctrl(ddc_block_id) + ->set_arg<double>("input_rate", radio_output_rate, chan); } for (size_t chan = 0; chan < _num_tx_chans_per_radio and _has_ducs; chan++) { const double radio_input_rate = radio_sptr->get_input_samp_rate(chan); - _device->get_block_ctrl(duc_block_id)->set_arg<double>("output_rate", radio_input_rate, chan); + _device->get_block_ctrl(duc_block_id) + ->set_arg<double>("output_rate", radio_input_rate, chan); } } } @@ -1036,31 +1141,32 @@ private: // attributes //! Stores a weak pointer for every streamer that's generated through this API. // Key is the channel number (same format as e.g. the set_rx_rate() call). - typedef std::map< size_t, boost::weak_ptr<uhd::rx_streamer> > rx_stream_map_type; + typedef std::map<size_t, boost::weak_ptr<uhd::rx_streamer>> rx_stream_map_type; rx_stream_map_type _rx_stream_cache; - typedef std::map< size_t, boost::weak_ptr<uhd::tx_streamer> > tx_stream_map_type; + typedef std::map<size_t, boost::weak_ptr<uhd::tx_streamer>> tx_stream_map_type; tx_stream_map_type _tx_stream_cache; graph::sptr _graph; }; legacy_compat::sptr legacy_compat::make( - uhd::device3::sptr device, - const uhd::device_addr_t &args -) { + uhd::device3::sptr device, const uhd::device_addr_t& args) +{ boost::lock_guard<boost::mutex> lock(_make_mutex); UHD_ASSERT_THROW(bool(device)); - static std::map<void *, boost::weak_ptr<legacy_compat> > legacy_cache; + static std::map<void*, boost::weak_ptr<legacy_compat>> legacy_cache; - if (legacy_cache.count(device.get()) and not legacy_cache.at(device.get()).expired()) { + if (legacy_cache.count(device.get()) + and not legacy_cache.at(device.get()).expired()) { legacy_compat::sptr legacy_compat_copy = legacy_cache.at(device.get()).lock(); UHD_ASSERT_THROW(bool(legacy_compat_copy)); - UHD_LEGACY_LOG() << "[legacy_compat] Using existing legacy compat object for this device." ; + UHD_LEGACY_LOG() + << "[legacy_compat] Using existing legacy compat object for this device."; return legacy_compat_copy; } - legacy_compat::sptr new_legacy_compat = boost::make_shared<legacy_compat_impl>(device, args); + legacy_compat::sptr new_legacy_compat = + boost::make_shared<legacy_compat_impl>(device, args); legacy_cache[device.get()] = new_legacy_compat; return new_legacy_compat; } - |