aboutsummaryrefslogtreecommitdiffstats
path: root/host/lib/usrp/usrp2/io_impl.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'host/lib/usrp/usrp2/io_impl.cpp')
-rw-r--r--host/lib/usrp/usrp2/io_impl.cpp230
1 files changed, 144 insertions, 86 deletions
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
index df452942c..eda2267bc 100644
--- a/host/lib/usrp/usrp2/io_impl.cpp
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -15,6 +15,7 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
+#include "validate_subdev_spec.hpp"
#include "../../transport/super_recv_packet_handler.hpp"
#include "../../transport/super_send_packet_handler.hpp"
#include "usrp2_impl.hpp"
@@ -22,8 +23,6 @@
#include <uhd/utils/log.hpp>
#include <uhd/utils/msg.hpp>
#include <uhd/exception.hpp>
-#include <uhd/usrp/mboard_props.hpp>
-#include <uhd/usrp/dsp_props.hpp>
#include <uhd/utils/byteswap.hpp>
#include <uhd/utils/thread_priority.hpp>
#include <uhd/transport/bounded_buffer.hpp>
@@ -54,11 +53,6 @@ static UHD_INLINE double from_time_dur(const pt::time_duration &time_dur){
/***********************************************************************
* constants
**********************************************************************/
-static const int underflow_flags = 0
- | async_metadata_t::EVENT_CODE_UNDERFLOW
- | async_metadata_t::EVENT_CODE_UNDERFLOW_IN_PACKET
-;
-
static const size_t vrt_send_header_offset_words32 = 1;
/***********************************************************************
@@ -134,15 +128,10 @@ private:
**********************************************************************/
struct usrp2_impl::io_impl{
- io_impl(std::vector<zero_copy_if::sptr> &dsp_xports):
- dsp_xports(dsp_xports), //the assumption is that all data transports should be identical
+ io_impl(void):
async_msg_fifo(100/*messages deep*/)
{
- for (size_t i = 0; i < dsp_xports.size(); i++){
- fc_mons.push_back(flow_control_monitor::sptr(new flow_control_monitor(
- usrp2_impl::sram_bytes/dsp_xports.front()->get_send_frame_size()
- )));
- }
+ /* NOP */
}
~io_impl(void){
@@ -151,14 +140,13 @@ struct usrp2_impl::io_impl{
}
managed_send_buffer::sptr get_send_buff(size_t chan, double timeout){
- const size_t index = send_map[chan];
- flow_control_monitor &fc_mon = *fc_mons[index];
+ flow_control_monitor &fc_mon = *fc_mons[chan];
//wait on flow control w/ timeout
if (not fc_mon.check_fc_condition(timeout)) return managed_send_buffer::sptr();
//get a buffer from the transport w/ timeout
- managed_send_buffer::sptr buff = dsp_xports[index]->get_send_buff(timeout);
+ managed_send_buffer::sptr buff = tx_xports[chan]->get_send_buff(timeout);
//write the flow control word into the buffer
if (buff.get()) buff->cast<boost::uint32_t *>()[0] = uhd::htonx(fc_mon.get_curr_seq_out());
@@ -166,15 +154,8 @@ struct usrp2_impl::io_impl{
return buff;
}
- std::vector<zero_copy_if::sptr> &dsp_xports;
-
- //mappings from channel index to dsp xport
- std::vector<size_t> send_map, recv_map;
-
- //previous state for each buffer
- std::vector<vrt::if_packet_info_t> prev_infos;
-
- //flow control monitors
+ //tx dsp: xports and flow control monitors
+ std::vector<zero_copy_if::sptr> tx_xports;
std::vector<flow_control_monitor::sptr> fc_mons;
//state management for the vrt packet handler code
@@ -182,9 +163,10 @@ struct usrp2_impl::io_impl{
sph::send_packet_handler send_handler;
//methods and variables for the pirate crew
- void recv_pirate_loop(boost::barrier &, usrp2_mboard_impl::sptr, zero_copy_if::sptr, size_t);
+ void recv_pirate_loop(boost::barrier &, zero_copy_if::sptr, size_t);
boost::thread_group recv_pirate_crew;
bounded_buffer<async_metadata_t> async_msg_fifo;
+ double tick_rate;
};
/***********************************************************************
@@ -195,7 +177,6 @@ struct usrp2_impl::io_impl{
**********************************************************************/
void usrp2_impl::io_impl::recv_pirate_loop(
boost::barrier &spawn_barrier,
- usrp2_mboard_impl::sptr mboard,
zero_copy_if::sptr err_xport,
size_t index
){
@@ -203,7 +184,7 @@ void usrp2_impl::io_impl::recv_pirate_loop(
set_thread_priority_safe();
//store a reference to the flow control monitor (offset by max dsps)
- flow_control_monitor &fc_mon = *(this->fc_mons[index*usrp2_mboard_impl::MAX_NUM_DSPS]);
+ flow_control_monitor &fc_mon = *(this->fc_mons[index]);
while (not boost::this_thread::interruption_requested()){
managed_recv_buffer::sptr buff = err_xport->get_recv_buff();
@@ -217,14 +198,14 @@ void usrp2_impl::io_impl::recv_pirate_loop(
vrt::if_hdr_unpack_be(vrt_hdr, if_packet_info);
//handle a tx async report message
- if (if_packet_info.sid == usrp2_impl::ASYNC_SID and if_packet_info.packet_type != vrt::if_packet_info_t::PACKET_TYPE_DATA){
+ if (if_packet_info.sid == USRP2_TX_ASYNC_SID and if_packet_info.packet_type != vrt::if_packet_info_t::PACKET_TYPE_DATA){
//fill in the async metadata
async_metadata_t metadata;
metadata.channel = index;
metadata.has_time_spec = if_packet_info.has_tsi and if_packet_info.has_tsf;
metadata.time_spec = time_spec_t(
- time_t(if_packet_info.tsi), size_t(if_packet_info.tsf), mboard->get_master_clock_freq()
+ time_t(if_packet_info.tsi), size_t(if_packet_info.tsf), tick_rate
);
metadata.event_code = async_metadata_t::event_code_t(sph::get_context_code(vrt_hdr, if_packet_info));
@@ -234,11 +215,17 @@ void usrp2_impl::io_impl::recv_pirate_loop(
fc_mon.update_fc_condition(uhd::ntohx(fc_word32));
continue;
}
-
- //print the famous U, and push the metadata into the message queue
- if (metadata.event_code & underflow_flags) UHD_MSG(fastpath) << "U";
//else UHD_MSG(often) << "metadata.event_code " << metadata.event_code << std::endl;
async_msg_fifo.push_with_pop_on_full(metadata);
+
+ if (metadata.event_code &
+ ( async_metadata_t::EVENT_CODE_UNDERFLOW
+ | async_metadata_t::EVENT_CODE_UNDERFLOW_IN_PACKET)
+ ) UHD_MSG(fastpath) << "U";
+ else if (metadata.event_code &
+ ( async_metadata_t::EVENT_CODE_SEQ_ERROR
+ | async_metadata_t::EVENT_CODE_SEQ_ERROR_IN_BURST)
+ ) UHD_MSG(fastpath) << "S";
}
else{
//TODO unknown received packet, may want to print error...
@@ -254,80 +241,151 @@ void usrp2_impl::io_impl::recv_pirate_loop(
**********************************************************************/
void usrp2_impl::io_init(void){
+ //setup rx otw type
+ _rx_otw_type.width = 16;
+ _rx_otw_type.shift = 0;
+ _rx_otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+
+ //setup tx otw type
+ _tx_otw_type.width = 16;
+ _tx_otw_type.shift = 0;
+ _tx_otw_type.byteorder = uhd::otw_type_t::BO_BIG_ENDIAN;
+
//create new io impl
- _io_impl = UHD_PIMPL_MAKE(io_impl, (dsp_xports));
+ _io_impl = UHD_PIMPL_MAKE(io_impl, ());
+
+ //init first so we dont have an access race
+ BOOST_FOREACH(const std::string &mb, _mbc.keys()){
+ //init the tx xport and flow control monitor
+ _io_impl->tx_xports.push_back(_mbc[mb].dsp_xports.at(0));
+ _io_impl->fc_mons.push_back(flow_control_monitor::sptr(new flow_control_monitor(
+ USRP2_SRAM_BYTES/_mbc[mb].dsp_xports.at(0)->get_send_frame_size()
+ )));
+ }
//create a new pirate thread for each zc if (yarr!!)
- boost::barrier spawn_barrier(_mboards.size()+1);
- for (size_t i = 0; i < _mboards.size(); i++){
+ boost::barrier spawn_barrier(_mbc.size()+1);
+ size_t index = 0;
+ BOOST_FOREACH(const std::string &mb, _mbc.keys()){
//spawn a new pirate to plunder the recv booty
_io_impl->recv_pirate_crew.create_thread(boost::bind(
&usrp2_impl::io_impl::recv_pirate_loop,
_io_impl.get(), boost::ref(spawn_barrier),
- _mboards.at(i), err_xports.at(i), i
+ _mbc[mb].err_xports.at(0), index++
));
}
spawn_barrier.wait();
- //update mapping here since it didnt b4 when io init not called first
- update_xport_channel_mapping();
-}
+ //init some handler stuff
+ _io_impl->recv_handler.set_vrt_unpacker(&vrt::if_hdr_unpack_be);
+ _io_impl->recv_handler.set_converter(_rx_otw_type);
+ _io_impl->send_handler.set_vrt_packer(&vrt::if_hdr_pack_be, vrt_send_header_offset_words32);
+ _io_impl->send_handler.set_converter(_tx_otw_type);
+ _io_impl->send_handler.set_max_samples_per_packet(get_max_send_samps_per_packet());
-void usrp2_impl::update_xport_channel_mapping(void){
- if (_io_impl.get() == NULL) return; //not inited yet
+ //set the packet threshold to be an entire socket buffer's worth
+ const size_t packets_per_sock_buff = 50e6/_mbc[_mbc.keys().front()].dsp_xports[0]->get_recv_frame_size();
+ _io_impl->recv_handler.set_alignment_failure_threshold(packets_per_sock_buff);
+}
- _io_impl->recv_map.clear();
- _io_impl->send_map.clear();
+void usrp2_impl::update_tick_rate(const double rate){
+ _io_impl->tick_rate = rate;
+ boost::mutex::scoped_lock recv_lock = _io_impl->recv_handler.get_scoped_lock();
+ _io_impl->recv_handler.set_tick_rate(rate);
+ boost::mutex::scoped_lock send_lock = _io_impl->send_handler.get_scoped_lock();
+ _io_impl->send_handler.set_tick_rate(rate);
+}
- for (size_t i = 0; i < _mboards.size(); i++){
+void usrp2_impl::update_rx_samp_rate(const double rate){
+ boost::mutex::scoped_lock recv_lock = _io_impl->recv_handler.get_scoped_lock();
+ _io_impl->recv_handler.set_samp_rate(rate);
+}
- subdev_spec_t rx_subdev_spec = _mboards[i]->get_link()[MBOARD_PROP_RX_SUBDEV_SPEC].as<subdev_spec_t>();
- for (size_t j = 0; j < rx_subdev_spec.size(); j++){
- _io_impl->recv_map.push_back(i*usrp2_mboard_impl::MAX_NUM_DSPS+j);
- UHD_LOG << "recv_map.back() " << _io_impl->recv_map.back() << std::endl;
- }
+void usrp2_impl::update_tx_samp_rate(const double rate){
+ boost::mutex::scoped_lock send_lock = _io_impl->send_handler.get_scoped_lock();
+ _io_impl->send_handler.set_samp_rate(rate);
+}
- subdev_spec_t tx_subdev_spec = _mboards[i]->get_link()[MBOARD_PROP_TX_SUBDEV_SPEC].as<subdev_spec_t>();
- for (size_t j = 0; j < tx_subdev_spec.size(); j++){
- _io_impl->send_map.push_back(i*usrp2_mboard_impl::MAX_NUM_DSPS+j);
- UHD_LOG << "send_map.back() " << _io_impl->send_map.back() << std::endl;
+static subdev_spec_t replace_zero_in_spec(const std::string &type, const subdev_spec_t &spec){
+ subdev_spec_t new_spec;
+ BOOST_FOREACH(const subdev_spec_pair_t &pair, spec){
+ if (pair.db_name == "0"){
+ UHD_MSG(warning)
+ << boost::format("In the %s subdevice specification: %s") % type % spec.to_string() << std::endl
+ << "Accepting dboard slot name \"0\" for backward compatibility." << std::endl
+ << "The official name of the dboard slot on USRP2/N-Series is \"A\"." << std::endl
+ ;
+ new_spec.push_back(subdev_spec_pair_t("A", pair.sd_name));
}
-
+ else new_spec.push_back(pair);
}
+ return new_spec;
+}
- //set all of the relevant properties on the handler
+subdev_spec_t usrp2_impl::update_rx_subdev_spec(const std::string &which_mb, const subdev_spec_t &spec_){
+ const subdev_spec_t spec = replace_zero_in_spec("RX", spec_);
boost::mutex::scoped_lock recv_lock = _io_impl->recv_handler.get_scoped_lock();
- _io_impl->recv_handler.resize(_io_impl->recv_map.size());
- _io_impl->recv_handler.set_vrt_unpacker(&vrt::if_hdr_unpack_be);
- _io_impl->recv_handler.set_tick_rate(_mboards.front()->get_master_clock_freq());
- //TODO temporarily use the first dsp rate until we support non-homo rates
- const std::string rx_dsp_name = _mboards.at(0)->get_link()[MBOARD_PROP_RX_DSP_NAMES].as<prop_names_t>().at(0);
- const double rx_host_rate = _mboards.at(0)->get_link()[named_prop_t(MBOARD_PROP_RX_DSP, rx_dsp_name)][DSP_PROP_HOST_RATE].as<double>();
- _io_impl->recv_handler.set_samp_rate(rx_host_rate);
- for (size_t chan = 0; chan < _io_impl->recv_handler.size(); chan++){
- _io_impl->recv_handler.set_xport_chan_get_buff(chan, boost::bind(
- &uhd::transport::zero_copy_if::get_recv_buff,
- _io_impl->dsp_xports[_io_impl->recv_map[chan]], _1
- ));
+ property_tree::path_type root = "/mboards/" + which_mb + "/dboards";
+
+ //sanity checking
+ validate_subdev_spec(_tree, spec, "rx", which_mb);
+
+ //setup mux for this spec
+ bool fe_swapped = false;
+ for (size_t i = 0; i < spec.size(); i++){
+ const std::string conn = _tree->access<std::string>(root / spec[i].db_name / "rx_frontends" / spec[i].sd_name / "connection").get();
+ if (i == 0 and (conn == "QI" or conn == "Q")) fe_swapped = true;
+ _mbc[which_mb].rx_dsps[i]->set_mux(conn, fe_swapped);
}
- _io_impl->recv_handler.set_converter(_rx_otw_type);
+ _mbc[which_mb].rx_fe->set_mux(fe_swapped);
+
+ //compute the new occupancy and resize
+ _mbc[which_mb].rx_chan_occ = spec.size();
+ size_t nchan = 0;
+ BOOST_FOREACH(const std::string &mb, _mbc.keys()) nchan += _mbc[mb].rx_chan_occ;
+ _io_impl->recv_handler.resize(nchan);
+
+ //bind new callbacks for the handler
+ size_t chan = 0;
+ BOOST_FOREACH(const std::string &mb, _mbc.keys()){
+ for (size_t dsp = 0; dsp < _mbc[mb].rx_chan_occ; dsp++){
+ _mbc[mb].rx_dsps[dsp]->set_nsamps_per_packet(get_max_recv_samps_per_packet()); //seems to be a good place to set this
+ _io_impl->recv_handler.set_xport_chan_get_buff(chan++, boost::bind(
+ &zero_copy_if::get_recv_buff, _mbc[mb].dsp_xports[dsp], _1
+ ));
+ }
+ }
+ return spec;
+}
- //set all of the relevant properties on the handler
+subdev_spec_t usrp2_impl::update_tx_subdev_spec(const std::string &which_mb, const subdev_spec_t &spec_){
+ const subdev_spec_t spec = replace_zero_in_spec("TX", spec_);
boost::mutex::scoped_lock send_lock = _io_impl->send_handler.get_scoped_lock();
- _io_impl->send_handler.resize(_io_impl->send_map.size());
- _io_impl->send_handler.set_vrt_packer(&vrt::if_hdr_pack_be, vrt_send_header_offset_words32);
- _io_impl->send_handler.set_tick_rate(_mboards.front()->get_master_clock_freq());
- //TODO temporarily use the first dsp rate until we support non-homo rates
- const std::string tx_dsp_name = _mboards.at(0)->get_link()[MBOARD_PROP_TX_DSP_NAMES].as<prop_names_t>().at(0);
- const double tx_host_rate = _mboards.at(0)->get_link()[named_prop_t(MBOARD_PROP_TX_DSP, tx_dsp_name)][DSP_PROP_HOST_RATE].as<double>();
- _io_impl->send_handler.set_samp_rate(tx_host_rate);
- for (size_t chan = 0; chan < _io_impl->send_handler.size(); chan++){
- _io_impl->send_handler.set_xport_chan_get_buff(chan, boost::bind(
- &usrp2_impl::io_impl::get_send_buff, _io_impl.get(), chan, _1
- ));
+ property_tree::path_type root = "/mboards/" + which_mb + "/dboards";
+
+ //sanity checking
+ validate_subdev_spec(_tree, spec, "tx", which_mb);
+
+ //set the mux for this spec
+ const std::string conn = _tree->access<std::string>(root / spec[0].db_name / "tx_frontends" / spec[0].sd_name / "connection").get();
+ _mbc[which_mb].tx_fe->set_mux(conn);
+
+ //compute the new occupancy and resize
+ _mbc[which_mb].tx_chan_occ = spec.size();
+ size_t nchan = 0;
+ BOOST_FOREACH(const std::string &mb, _mbc.keys()) nchan += _mbc[mb].tx_chan_occ;
+ _io_impl->send_handler.resize(nchan);
+
+ //bind new callbacks for the handler
+ size_t chan = 0, i = 0;
+ BOOST_FOREACH(const std::string &mb, _mbc.keys()){
+ for (size_t dsp = 0; dsp < _mbc[mb].tx_chan_occ; dsp++){
+ _io_impl->send_handler.set_xport_chan_get_buff(chan++, boost::bind(
+ &usrp2_impl::io_impl::get_send_buff, _io_impl.get(), i++, _1
+ ));
+ }
}
- _io_impl->send_handler.set_converter(_tx_otw_type);
- _io_impl->send_handler.set_max_samples_per_packet(get_max_send_samps_per_packet());
+ return spec;
}
/***********************************************************************
@@ -349,7 +407,7 @@ size_t usrp2_impl::get_max_send_samps_per_packet(void) const{
+ vrt_send_header_offset_words32*sizeof(boost::uint32_t)
- sizeof(vrt::if_packet_info_t().cid) //no class id ever used
;
- const size_t bpp = dsp_xports.front()->get_send_frame_size() - hdr_size;
+ const size_t bpp = _mbc[_mbc.keys().front()].dsp_xports[0]->get_send_frame_size() - hdr_size;
return bpp/_tx_otw_type.get_sample_size();
}
@@ -374,7 +432,7 @@ size_t usrp2_impl::get_max_recv_samps_per_packet(void) const{
+ sizeof(vrt::if_packet_info_t().tlr) //forced to have trailer
- sizeof(vrt::if_packet_info_t().cid) //no class id ever used
;
- const size_t bpp = dsp_xports.front()->get_recv_frame_size() - hdr_size;
+ const size_t bpp = _mbc[_mbc.keys().front()].dsp_xports[0]->get_recv_frame_size() - hdr_size;
return bpp/_rx_otw_type.get_sample_size();
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-03 00:06:47 +0000