From 178ac3f1c9950d383c8f64b3df464c0f943c4a23 Mon Sep 17 00:00:00 2001 From: Ben Hilburn Date: Tue, 4 Feb 2014 11:04:07 -0800 Subject: Merging USRP X300 and X310 support!! --- host/lib/usrp/x300/x300_io_impl.cpp | 652 ++++++++++++++++++++++++++++++++++++ 1 file changed, 652 insertions(+) create mode 100644 host/lib/usrp/x300/x300_io_impl.cpp (limited to 'host/lib/usrp/x300/x300_io_impl.cpp') diff --git a/host/lib/usrp/x300/x300_io_impl.cpp b/host/lib/usrp/x300/x300_io_impl.cpp new file mode 100644 index 000000000..00a31b8d6 --- /dev/null +++ b/host/lib/usrp/x300/x300_io_impl.cpp @@ -0,0 +1,652 @@ +// +// Copyright 2013-2014 Ettus Research LLC +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// + +#include "x300_regs.hpp" +#include "x300_impl.hpp" +#include "validate_subdev_spec.hpp" +#include "../../transport/super_recv_packet_handler.hpp" +#include "../../transport/super_send_packet_handler.hpp" +#include +#include "async_packet_handler.hpp" +#include +#include +#include +#include +#include +#include + +using namespace uhd; +using namespace uhd::usrp; +using namespace uhd::transport; + +/*********************************************************************** + * update streamer rates + **********************************************************************/ +void x300_impl::update_tick_rate(mboard_members_t &mb, const double rate) +{ + BOOST_FOREACH(const size_t &dspno, mb.rx_streamers.keys()) + { + boost::shared_ptr my_streamer = + boost::dynamic_pointer_cast(mb.rx_streamers[dspno].lock()); + if (my_streamer) my_streamer->set_tick_rate(rate); + } + BOOST_FOREACH(const size_t &dspno, mb.tx_streamers.keys()) + { + boost::shared_ptr my_streamer = + boost::dynamic_pointer_cast(mb.tx_streamers[dspno].lock()); + if (my_streamer) my_streamer->set_tick_rate(rate); + } +} + +void x300_impl::update_rx_samp_rate(mboard_members_t &mb, const size_t dspno, const double rate) +{ + if (not mb.rx_streamers.has_key(dspno)) return; + boost::shared_ptr my_streamer = + boost::dynamic_pointer_cast(mb.rx_streamers[dspno].lock()); + if (not my_streamer) return; + my_streamer->set_samp_rate(rate); + const double adj = mb.radio_perifs[dspno].ddc->get_scaling_adjustment(); + my_streamer->set_scale_factor(adj); +} + +void x300_impl::update_tx_samp_rate(mboard_members_t &mb, const size_t dspno, const double rate) +{ + if (not mb.tx_streamers.has_key(dspno)) return; + boost::shared_ptr my_streamer = + boost::dynamic_pointer_cast(mb.tx_streamers[dspno].lock()); + if (not my_streamer) return; + my_streamer->set_samp_rate(rate); + const double adj = mb.radio_perifs[dspno].duc->get_scaling_adjustment(); + my_streamer->set_scale_factor(adj); +} + +/*********************************************************************** + * Setup dboard muxing for IQ + **********************************************************************/ +void x300_impl::update_rx_subdev_spec(const size_t mb_i, const subdev_spec_t &spec) +{ + const std::string mb_name = boost::lexical_cast(mb_i); + fs_path root = "/mboards/"+mb_name+"/dboards"; + + //sanity checking + validate_subdev_spec(_tree, spec, "rx", mb_name); + UHD_ASSERT_THROW(spec.size() <= 2); + if (spec.size() > 0) UHD_ASSERT_THROW(spec[0].db_name == "A"); + if (spec.size() > 1) UHD_ASSERT_THROW(spec[1].db_name == "B"); + + //setup mux for this spec + for (size_t i = 0; i < 2; i++) + { + //extract db name + const std::string db_name = (i == 0)? "A" : "B"; + if (i < spec.size()) UHD_ASSERT_THROW(spec[i].db_name == db_name); + + //extract fe name + std::string fe_name; + if (i < spec.size()) fe_name = spec[i].sd_name; + else fe_name = _tree->list(root / db_name / "rx_frontends").front(); + + //extract connection + const std::string conn = _tree->access(root / db_name / "rx_frontends" / fe_name / "connection").get(); + + //swap condition + const bool fe_swapped = (conn == "QI" or conn == "Q"); + _mb[mb_i].radio_perifs[i].ddc->set_mux(conn, fe_swapped); + //see usrp/io_impl.cpp if multiple DSPs share the frontend: + _mb[mb_i].radio_perifs[i].rx_fe->set_mux(fe_swapped); + } + + _mb[mb_i].rx_fe_map = spec; +} + +void x300_impl::update_tx_subdev_spec(const size_t mb_i, const subdev_spec_t &spec) +{ + const std::string mb_name = boost::lexical_cast(mb_i); + fs_path root = "/mboards/"+mb_name+"/dboards"; + + //sanity checking + validate_subdev_spec(_tree, spec, "tx", mb_name); + UHD_ASSERT_THROW(spec.size() <= 2); + if (spec.size() > 0) UHD_ASSERT_THROW(spec[0].db_name == "A"); + if (spec.size() > 1) UHD_ASSERT_THROW(spec[1].db_name == "B"); + + //set the mux for this spec + for (size_t i = 0; i < 2; i++) + { + //extract db name + const std::string db_name = (i == 0)? "A" : "B"; + if (i < spec.size()) UHD_ASSERT_THROW(spec[i].db_name == db_name); + + //extract fe name + std::string fe_name; + if (i < spec.size()) fe_name = spec[i].sd_name; + else fe_name = _tree->list(root / db_name / "tx_frontends").front(); + + //extract connection + const std::string conn = _tree->access(root / db_name / "tx_frontends" / fe_name / "connection").get(); + + //swap condition + _mb[mb_i].radio_perifs[i].tx_fe->set_mux(conn); + + } + + _mb[mb_i].tx_fe_map = spec; +} + +/*********************************************************************** + * VITA stuff + **********************************************************************/ +static void x300_if_hdr_unpack_be( + const boost::uint32_t *packet_buff, + vrt::if_packet_info_t &if_packet_info +){ + if_packet_info.link_type = vrt::if_packet_info_t::LINK_TYPE_CHDR; + return vrt::if_hdr_unpack_be(packet_buff, if_packet_info); +} + +static void x300_if_hdr_pack_be( + boost::uint32_t *packet_buff, + vrt::if_packet_info_t &if_packet_info +){ + if_packet_info.link_type = vrt::if_packet_info_t::LINK_TYPE_CHDR; + return vrt::if_hdr_pack_be(packet_buff, if_packet_info); +} + +static void x300_if_hdr_unpack_le( + const boost::uint32_t *packet_buff, + vrt::if_packet_info_t &if_packet_info +){ + if_packet_info.link_type = vrt::if_packet_info_t::LINK_TYPE_CHDR; + return vrt::if_hdr_unpack_le(packet_buff, if_packet_info); +} + +static void x300_if_hdr_pack_le( + boost::uint32_t *packet_buff, + vrt::if_packet_info_t &if_packet_info +){ + if_packet_info.link_type = vrt::if_packet_info_t::LINK_TYPE_CHDR; + return vrt::if_hdr_pack_le(packet_buff, if_packet_info); +} + +/*********************************************************************** + * RX flow control handler + **********************************************************************/ +static size_t get_rx_flow_control_window(size_t frame_size, size_t sw_buff_size, const device_addr_t& rx_args) +{ + double fullness_factor = rx_args.cast("recv_buff_fullness", X300_RX_SW_BUFF_FULL_FACTOR); + + if (fullness_factor < 0.01 || fullness_factor > 1) { + throw uhd::value_error("recv_buff_fullness must be between 0.01 and 1 inclusive (1% to 100%)"); + } + + size_t window_in_pkts = (static_cast(sw_buff_size * fullness_factor) / frame_size); + if (window_in_pkts == 0) { + throw uhd::value_error("recv_buff_size must be larger than the recv_frame_size."); + } + return window_in_pkts; +} + +static void handle_rx_flowctrl(const boost::uint32_t sid, zero_copy_if::sptr xport, bool big_endian, boost::shared_ptr seq32_state, const size_t last_seq) +{ + managed_send_buffer::sptr buff = xport->get_send_buff(0.0); + if (not buff) + { + throw uhd::runtime_error("handle_rx_flowctrl timed out getting a send buffer"); + } + boost::uint32_t *pkt = buff->cast(); + + //recover seq32 + boost::uint32_t &seq32 = *seq32_state; + const size_t seq12 = seq32 & 0xfff; + if (last_seq < seq12) seq32 += (1 << 12); + seq32 &= ~0xfff; + seq32 |= last_seq; + + //load packet info + vrt::if_packet_info_t packet_info; + packet_info.packet_type = vrt::if_packet_info_t::PACKET_TYPE_CONTEXT; + packet_info.num_payload_words32 = 2; + packet_info.num_payload_bytes = packet_info.num_payload_words32*sizeof(boost::uint32_t); + packet_info.packet_count = seq32; + packet_info.sob = false; + packet_info.eob = false; + packet_info.sid = sid; + packet_info.has_sid = true; + packet_info.has_cid = false; + packet_info.has_tsi = false; + packet_info.has_tsf = false; + packet_info.has_tlr = false; + + //load header + if (big_endian) + x300_if_hdr_pack_be(pkt, packet_info); + else + x300_if_hdr_pack_le(pkt, packet_info); + + //load payload + pkt[packet_info.num_header_words32+0] = uhd::htonx(0); + pkt[packet_info.num_header_words32+1] = uhd::htonx(seq32); + + //send the buffer over the interface + buff->commit(sizeof(boost::uint32_t)*(packet_info.num_packet_words32)); +} + + +/*********************************************************************** + * TX flow control handler + **********************************************************************/ +struct x300_tx_fc_guts_t +{ + x300_tx_fc_guts_t(void): + stream_channel(0), + device_channel(0), + last_seq_out(0), + last_seq_ack(0), + seq_queue(1){} + size_t stream_channel; + size_t device_channel; + size_t last_seq_out; + size_t last_seq_ack; + bounded_buffer seq_queue; + boost::shared_ptr async_queue; + boost::shared_ptr old_async_queue; +}; + +static size_t get_tx_flow_control_window(size_t frame_size, const device_addr_t& tx_args) +{ + double hw_buff_size = tx_args.cast("send_buff_size", X300_TX_HW_BUFF_SIZE); + size_t window_in_pkts = (static_cast(hw_buff_size) / frame_size); + if (window_in_pkts == 0) { + throw uhd::value_error("send_buff_size must be larger than the send_frame_size."); + } + return window_in_pkts; +} + +static void handle_tx_async_msgs(boost::shared_ptr guts, zero_copy_if::sptr xport, bool big_endian, x300_clock_ctrl::sptr clock) +{ + managed_recv_buffer::sptr buff = xport->get_recv_buff(); + if (not buff) return; + + //extract packet info + vrt::if_packet_info_t if_packet_info; + if_packet_info.num_packet_words32 = buff->size()/sizeof(boost::uint32_t); + const boost::uint32_t *packet_buff = buff->cast(); + + //unpacking can fail + uint32_t (*endian_conv)(uint32_t) = uhd::ntohx; + try + { + if (big_endian) + { + x300_if_hdr_unpack_be(packet_buff, if_packet_info); + endian_conv = uhd::ntohx; + } + else + { + x300_if_hdr_unpack_le(packet_buff, if_packet_info); + endian_conv = uhd::wtohx; + } + } + catch(const std::exception &ex) + { + UHD_MSG(error) << "Error parsing async message packet: " << ex.what() << std::endl; + return; + } + + //catch the flow control packets and react + if (endian_conv(packet_buff[if_packet_info.num_header_words32+0]) == 0) + { + const size_t seq = endian_conv(packet_buff[if_packet_info.num_header_words32+1]); + guts->seq_queue.push_with_haste(seq); + return; + } + + //fill in the async metadata + async_metadata_t metadata; + load_metadata_from_buff( + endian_conv, metadata, if_packet_info, packet_buff, + clock->get_master_clock_rate(), guts->stream_channel); + guts->async_queue->push_with_pop_on_full(metadata); + metadata.channel = guts->device_channel; + guts->old_async_queue->push_with_pop_on_full(metadata); + standard_async_msg_prints(metadata); +} + +static managed_send_buffer::sptr get_tx_buff_with_flowctrl( + task::sptr /*holds ref*/, + boost::shared_ptr guts, + zero_copy_if::sptr xport, + size_t fc_pkt_window, + const double timeout +){ + while (true) + { + const size_t delta = (guts->last_seq_out & 0xfff) - (guts->last_seq_ack & 0xfff); + if ((delta & 0xfff) <= fc_pkt_window) break; + + const bool ok = guts->seq_queue.pop_with_timed_wait(guts->last_seq_ack, timeout); + if (not ok) return managed_send_buffer::sptr(); //timeout waiting for flow control + } + + managed_send_buffer::sptr buff = xport->get_send_buff(timeout); + if (buff) guts->last_seq_out++; //update seq, this will actually be a send + return buff; +} + +/*********************************************************************** + * Async Data + **********************************************************************/ +bool x300_impl::recv_async_msg( + async_metadata_t &async_metadata, double timeout +){ + return _async_md->pop_with_timed_wait(async_metadata, timeout); +} + +/*********************************************************************** + * Receive streamer + **********************************************************************/ +rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) +{ + boost::mutex::scoped_lock lock(_transport_setup_mutex); + stream_args_t args = args_; + + //setup defaults for unspecified values + if (not args.otw_format.empty() and args.otw_format != "sc16") + { + throw uhd::value_error("x300_impl::get_rx_stream only supports otw_format sc16"); + } + args.otw_format = "sc16"; + args.channels = args.channels.empty()? std::vector(1, 0) : args.channels; + + boost::shared_ptr my_streamer; + for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) + { + const size_t chan = args.channels[stream_i]; + size_t mb_chan = chan, mb_index = 0; + BOOST_FOREACH(mboard_members_t &mb, _mb) + { + if (mb_chan < mb.rx_fe_map.size()) break; + else mb_chan -= mb.rx_fe_map.size(); + mb_index++; + } + mboard_members_t &mb = _mb[mb_index]; + radio_perifs_t &perif = mb.radio_perifs[mb_chan]; + + //setup the dsp transport hints (default to a large recv buff) + device_addr_t device_addr = mb.recv_args; + if (not device_addr.has_key("recv_buff_size")) + { + if (mb.xport_path != "nirio") { + //For the ethernet transport, the buffer has to be set before creating + //the transport because it is independent of the frame size and # frames + //For nirio, the buffer size is not configurable by the user + #if defined(UHD_PLATFORM_MACOS) || defined(UHD_PLATFORM_BSD) + //limit buffer resize on macos or it will error + device_addr["recv_buff_size"] = boost::lexical_cast(X300_RX_SW_BUFF_SIZE_ETH_MACOS); + #elif defined(UHD_PLATFORM_LINUX) || defined(UHD_PLATFORM_WIN32) + //set to half-a-second of buffering at max rate + device_addr["recv_buff_size"] = boost::lexical_cast(X300_RX_SW_BUFF_SIZE_ETH); + #endif + } + } + + //allocate sid and create transport + uint8_t dest = (mb_chan == 0)? X300_XB_DST_R0 : X300_XB_DST_R1; + boost::uint32_t data_sid; + UHD_LOG << "creating rx stream " << device_addr.to_string() << std::endl; + both_xports_t xport = this->make_transport(mb_index, dest, X300_RADIO_DEST_PREFIX_RX, device_addr, data_sid); + UHD_LOG << boost::format("data_sid = 0x%08x, actual recv_buff_size = %d\n") % data_sid % xport.recv_buff_size << std::endl; + + //calculate packet size + static const size_t hdr_size = 0 + + vrt::num_vrl_words32*sizeof(boost::uint32_t) + + vrt::max_if_hdr_words32*sizeof(boost::uint32_t) + + sizeof(vrt::if_packet_info_t().tlr) //forced to have trailer + - sizeof(vrt::if_packet_info_t().cid) //no class id ever used + - sizeof(vrt::if_packet_info_t().tsi) //no int time ever used + ; + const size_t bpp = xport.recv->get_recv_frame_size() - hdr_size; + const size_t bpi = convert::get_bytes_per_item(args.otw_format); + const size_t spp = unsigned(args.args.cast("spp", bpp/bpi)); + + //make the new streamer given the samples per packet + if (not my_streamer) my_streamer = boost::make_shared(spp); + my_streamer->resize(args.channels.size()); + + //init some streamer stuff + std::string conv_endianness; + if (mb.if_pkt_is_big_endian) { + my_streamer->set_vrt_unpacker(&x300_if_hdr_unpack_be); + conv_endianness = "be"; + } else { + my_streamer->set_vrt_unpacker(&x300_if_hdr_unpack_le); + conv_endianness = "le"; + } + + //set the converter + uhd::convert::id_type id; + id.input_format = args.otw_format + "_item32_" + conv_endianness; + id.num_inputs = 1; + id.output_format = args.cpu_format; + id.num_outputs = 1; + my_streamer->set_converter(id); + + perif.framer->clear(); + perif.framer->set_nsamps_per_packet(spp); //seems to be a good place to set this + perif.framer->set_sid((data_sid << 16) | (data_sid >> 16)); + perif.framer->setup(args); + perif.ddc->setup(args); + + //flow control setup + const size_t fc_window = get_rx_flow_control_window(xport.recv->get_recv_frame_size(), xport.recv_buff_size, device_addr); + const size_t fc_handle_window = std::max(1, fc_window / X300_RX_FC_REQUEST_FREQ); + + UHD_LOG << "RX Flow Control Window = " << fc_window << ", RX Flow Control Handler Window = " << fc_handle_window << std::endl; + + perif.framer->configure_flow_control(fc_window); + + boost::shared_ptr seq32(new boost::uint32_t(0)); + //Give the streamer a functor to get the recv_buffer + //bind requires a zero_copy_if::sptr to add a streamer->xport lifetime dependency + my_streamer->set_xport_chan_get_buff( + stream_i, + boost::bind(&zero_copy_if::get_recv_buff, xport.recv, _1), + true /*flush*/ + ); + //Give the streamer a functor to handle overflows + //bind requires a weak_ptr to break the a streamer->streamer circular dependency + //Using "this" is OK because we know that x300_impl will outlive the streamer + my_streamer->set_overflow_handler( + stream_i, + boost::bind(&x300_impl::handle_overflow, this, boost::ref(perif), boost::weak_ptr(my_streamer)) + ); + //Give the streamer a functor to send flow control messages + //handle_rx_flowctrl is static and has no lifetime issues + my_streamer->set_xport_handle_flowctrl( + stream_i, boost::bind(&handle_rx_flowctrl, data_sid, xport.send, mb.if_pkt_is_big_endian, seq32, _1), + fc_handle_window, + true/*init*/ + ); + //Give the streamer a functor issue stream cmd + //bind requires a rx_vita_core_3000::sptr to add a streamer->framer lifetime dependency + my_streamer->set_issue_stream_cmd( + stream_i, boost::bind(&rx_vita_core_3000::issue_stream_command, perif.framer, _1) + ); + + //Store a weak pointer to prevent a streamer->x300_impl->streamer circular dependency + mb.rx_streamers[mb_chan] = boost::weak_ptr(my_streamer); + + //sets all tick and samp rates on this streamer + const fs_path mb_path = "/mboards/"+boost::lexical_cast(mb_index); + _tree->access(mb_path / "tick_rate").update(); + _tree->access(mb_path / "rx_dsps" / boost::lexical_cast(mb_chan) / "rate" / "value").update(); + } + + return my_streamer; +} + +void x300_impl::handle_overflow(x300_impl::radio_perifs_t &perif, boost::weak_ptr streamer) +{ + boost::shared_ptr my_streamer = + boost::dynamic_pointer_cast(streamer.lock()); + if (not my_streamer) return; //If the rx_streamer has expired then overflow handling makes no sense. + + if (my_streamer->get_num_channels() == 1) + { + perif.framer->handle_overflow(); + return; + } + + ///////////////////////////////////////////////////////////// + // MIMO overflow recovery time + ///////////////////////////////////////////////////////////// + //find out if we were in continuous mode before stopping + const bool in_continuous_streaming_mode = perif.framer->in_continuous_streaming_mode(); + //stop streaming + my_streamer->issue_stream_cmd(stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS); + //flush transports + my_streamer->flush_all(0.001); + //restart streaming + if (in_continuous_streaming_mode) + { + stream_cmd_t stream_cmd(stream_cmd_t::STREAM_MODE_START_CONTINUOUS); + stream_cmd.stream_now = false; + stream_cmd.time_spec = perif.time64->get_time_now() + time_spec_t(0.01); + my_streamer->issue_stream_cmd(stream_cmd); + } +} + +/*********************************************************************** + * Transmit streamer + **********************************************************************/ +tx_streamer::sptr x300_impl::get_tx_stream(const uhd::stream_args_t &args_) +{ + boost::mutex::scoped_lock lock(_transport_setup_mutex); + stream_args_t args = args_; + + //setup defaults for unspecified values + if (not args.otw_format.empty() and args.otw_format != "sc16") + { + throw uhd::value_error("x300_impl::get_rx_stream only supports otw_format sc16"); + } + args.otw_format = "sc16"; + args.channels = args.channels.empty()? std::vector(1, 0) : args.channels; + + //shared async queue for all channels in streamer + boost::shared_ptr async_md(new async_md_type(1000/*messages deep*/)); + + boost::shared_ptr my_streamer; + for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) + { + const size_t chan = args.channels[stream_i]; + size_t mb_chan = chan, mb_index = 0; + BOOST_FOREACH(mboard_members_t &mb, _mb) + { + if (mb_chan < mb.tx_fe_map.size()) break; + else mb_chan -= mb.tx_fe_map.size(); + mb_index++; + } + mboard_members_t &mb = _mb[mb_index]; + radio_perifs_t &perif = mb.radio_perifs[mb_chan]; + + //setup the dsp transport hints (TODO) + device_addr_t device_addr = mb.send_args; + + //allocate sid and create transport + uint8_t dest = (mb_chan == 0)? X300_XB_DST_R0 : X300_XB_DST_R1; + boost::uint32_t data_sid; + UHD_LOG << "creating tx stream " << device_addr.to_string() << std::endl; + both_xports_t xport = this->make_transport(mb_index, dest, X300_RADIO_DEST_PREFIX_TX, device_addr, data_sid); + UHD_LOG << boost::format("data_sid = 0x%08x\n") % data_sid << std::endl; + + //calculate packet size + static const size_t hdr_size = 0 + + vrt::num_vrl_words32*sizeof(boost::uint32_t) + + vrt::max_if_hdr_words32*sizeof(boost::uint32_t) + //+ sizeof(vrt::if_packet_info_t().tlr) //forced to have trailer + - sizeof(vrt::if_packet_info_t().cid) //no class id ever used + - sizeof(vrt::if_packet_info_t().tsi) //no int time ever used + ; + const size_t bpp = xport.send->get_send_frame_size() - hdr_size; + const size_t bpi = convert::get_bytes_per_item(args.otw_format); + const size_t spp = unsigned(args.args.cast("spp", bpp/bpi)); + + //make the new streamer given the samples per packet + if (not my_streamer) my_streamer = boost::make_shared(spp); + my_streamer->resize(args.channels.size()); + + std::string conv_endianness; + if (mb.if_pkt_is_big_endian) { + my_streamer->set_vrt_packer(&x300_if_hdr_pack_be); + conv_endianness = "be"; + } else { + my_streamer->set_vrt_packer(&x300_if_hdr_pack_le); + conv_endianness = "le"; + } + + //set the converter + uhd::convert::id_type id; + id.input_format = args.cpu_format; + id.num_inputs = 1; + id.output_format = args.otw_format + "_item32_" + conv_endianness; + id.num_outputs = 1; + my_streamer->set_converter(id); + + perif.deframer->clear(); + perif.deframer->setup(args); + perif.duc->setup(args); + + //flow control setup + size_t fc_window = get_tx_flow_control_window(xport.send->get_send_frame_size(), device_addr); //In packets + const size_t fc_handle_window = std::max(1, fc_window/X300_TX_FC_RESPONSE_FREQ); + + UHD_LOG << "TX Flow Control Window = " << fc_window << ", TX Flow Control Handler Window = " << fc_handle_window << std::endl; + + perif.deframer->configure_flow_control(0/*cycs off*/, fc_handle_window); + boost::shared_ptr guts(new x300_tx_fc_guts_t()); + guts->stream_channel = stream_i; + guts->device_channel = chan; + guts->async_queue = async_md; + guts->old_async_queue = _async_md; + task::sptr task = task::make(boost::bind(&handle_tx_async_msgs, guts, xport.recv, mb.if_pkt_is_big_endian, mb.clock)); + + //Give the streamer a functor to get the send buffer + //get_tx_buff_with_flowctrl is static so bind has no lifetime issues + //xport.send (sptr) is required to add streamer->data-transport lifetime dependency + //task (sptr) is required to add a streamer->async-handler lifetime dependency + my_streamer->set_xport_chan_get_buff( + stream_i, + boost::bind(&get_tx_buff_with_flowctrl, task, guts, xport.send, fc_window, _1) + ); + //Give the streamer a functor handled received async messages + my_streamer->set_async_receiver( + boost::bind(&async_md_type::pop_with_timed_wait, async_md, _1, _2) + ); + my_streamer->set_xport_chan_sid(stream_i, true, data_sid); + my_streamer->set_enable_trailer(false); //TODO not implemented trailer support yet + + //Store a weak pointer to prevent a streamer->x300_impl->streamer circular dependency + mb.tx_streamers[mb_chan] = boost::weak_ptr(my_streamer); + + //sets all tick and samp rates on this streamer + const fs_path mb_path = "/mboards/"+boost::lexical_cast(mb_index); + _tree->access(mb_path / "tick_rate").update(); + _tree->access(mb_path / "tx_dsps" / boost::lexical_cast(mb_chan) / "rate" / "value").update(); + } + + return my_streamer; +} -- cgit v1.2.3 From 81f9036788edbdb3498ac3b60b3e37791aab3e2b Mon Sep 17 00:00:00 2001 From: Martin Braun Date: Fri, 21 Feb 2014 13:39:47 +0100 Subject: x300: remove data that was duplicating property tree --- host/lib/usrp/x300/x300_impl.hpp | 4 ---- host/lib/usrp/x300/x300_io_impl.cpp | 35 +++++++++++++++++++---------------- 2 files changed, 19 insertions(+), 20 deletions(-) (limited to 'host/lib/usrp/x300/x300_io_impl.cpp') diff --git a/host/lib/usrp/x300/x300_impl.hpp b/host/lib/usrp/x300/x300_impl.hpp index 1fb3676a0..62ec0f83a 100644 --- a/host/lib/usrp/x300/x300_impl.hpp +++ b/host/lib/usrp/x300/x300_impl.hpp @@ -194,10 +194,6 @@ private: radio_perifs_t radio_perifs[2]; uhd::usrp::dboard_eeprom_t db_eeproms[8]; - //per mboard frontend mapping - uhd::usrp::subdev_spec_t rx_fe_map; - uhd::usrp::subdev_spec_t tx_fe_map; - //other perifs on mboard x300_clock_ctrl::sptr clock; uhd::gps_ctrl::sptr gps; diff --git a/host/lib/usrp/x300/x300_io_impl.cpp b/host/lib/usrp/x300/x300_io_impl.cpp index 00a31b8d6..603eb5704 100644 --- a/host/lib/usrp/x300/x300_io_impl.cpp +++ b/host/lib/usrp/x300/x300_io_impl.cpp @@ -109,8 +109,6 @@ void x300_impl::update_rx_subdev_spec(const size_t mb_i, const subdev_spec_t &sp //see usrp/io_impl.cpp if multiple DSPs share the frontend: _mb[mb_i].radio_perifs[i].rx_fe->set_mux(fe_swapped); } - - _mb[mb_i].rx_fe_map = spec; } void x300_impl::update_tx_subdev_spec(const size_t mb_i, const subdev_spec_t &spec) @@ -143,8 +141,6 @@ void x300_impl::update_tx_subdev_spec(const size_t mb_i, const subdev_spec_t &sp _mb[mb_i].radio_perifs[i].tx_fe->set_mux(conn); } - - _mb[mb_i].tx_fe_map = spec; } /*********************************************************************** @@ -376,13 +372,17 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) { const size_t chan = args.channels[stream_i]; - size_t mb_chan = chan, mb_index = 0; - BOOST_FOREACH(mboard_members_t &mb, _mb) - { - if (mb_chan < mb.rx_fe_map.size()) break; - else mb_chan -= mb.rx_fe_map.size(); - mb_index++; + size_t mb_chan = chan, mb_index; + for (mb_index = 0; mb_index < _mb.size(); mb_index++) { + const subdev_spec_t &curr_subdev_spec = + _tree->access("/mboards/" + boost::lexical_cast(mb_index) / "rx_subdev_spec").get(); + if (mb_chan < curr_subdev_spec.size()) { + break; + } else { + mb_chan -= curr_subdev_spec.size(); + } } + mboard_members_t &mb = _mb[mb_index]; radio_perifs_t &perif = mb.radio_perifs[mb_chan]; @@ -553,12 +553,15 @@ tx_streamer::sptr x300_impl::get_tx_stream(const uhd::stream_args_t &args_) for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) { const size_t chan = args.channels[stream_i]; - size_t mb_chan = chan, mb_index = 0; - BOOST_FOREACH(mboard_members_t &mb, _mb) - { - if (mb_chan < mb.tx_fe_map.size()) break; - else mb_chan -= mb.tx_fe_map.size(); - mb_index++; + size_t mb_chan = chan, mb_index; + for (mb_index = 0; mb_index < _mb.size(); mb_index++) { + const subdev_spec_t &curr_subdev_spec = + _tree->access("/mboards/" + boost::lexical_cast(mb_index) / "tx_subdev_spec").get(); + if (mb_chan < curr_subdev_spec.size()) { + break; + } else { + mb_chan -= curr_subdev_spec.size(); + } } mboard_members_t &mb = _mb[mb_index]; radio_perifs_t &perif = mb.radio_perifs[mb_chan]; -- cgit v1.2.3 From 2047b85cf090f0c978da24e4c14bb674d2803bcd Mon Sep 17 00:00:00 2001 From: Martin Braun Date: Fri, 21 Feb 2014 13:58:14 +0100 Subject: x300: merged subdev update routines for tx and rx --- host/lib/usrp/x300/x300_impl.cpp | 4 +-- host/lib/usrp/x300/x300_impl.hpp | 9 ++++-- host/lib/usrp/x300/x300_io_impl.cpp | 59 +++++++++++-------------------------- 3 files changed, 26 insertions(+), 46 deletions(-) (limited to 'host/lib/usrp/x300/x300_io_impl.cpp') diff --git a/host/lib/usrp/x300/x300_impl.cpp b/host/lib/usrp/x300/x300_impl.cpp index b20897fc6..6a3ac5363 100644 --- a/host/lib/usrp/x300/x300_impl.cpp +++ b/host/lib/usrp/x300/x300_impl.cpp @@ -733,9 +733,9 @@ void x300_impl::setup_mb(const size_t mb_i, const uhd::device_addr_t &dev_addr) // create frontend mapping //////////////////////////////////////////////////////////////////// _tree->create(mb_path / "rx_subdev_spec") - .subscribe(boost::bind(&x300_impl::update_rx_subdev_spec, this, mb_i, _1)); + .subscribe(boost::bind(&x300_impl::update_subdev_spec, this, "rx", mb_i, _1)); _tree->create(mb_path / "tx_subdev_spec") - .subscribe(boost::bind(&x300_impl::update_tx_subdev_spec, this, mb_i, _1)); + .subscribe(boost::bind(&x300_impl::update_subdev_spec, this, "tx", mb_i, _1)); //////////////////////////////////////////////////////////////////// // and do the misc mboard sensors diff --git a/host/lib/usrp/x300/x300_impl.hpp b/host/lib/usrp/x300/x300_impl.hpp index 62ec0f83a..ed8d29892 100644 --- a/host/lib/usrp/x300/x300_impl.hpp +++ b/host/lib/usrp/x300/x300_impl.hpp @@ -284,8 +284,13 @@ private: void set_rx_fe_corrections(const uhd::fs_path &mb_path, const std::string &fe_name, const double lo_freq); - void update_rx_subdev_spec(const size_t, const uhd::usrp::subdev_spec_t &spec); - void update_tx_subdev_spec(const size_t, const uhd::usrp::subdev_spec_t &spec); + /*! Update the IQ MUX settings for the radio peripheral according to given subdev spec + * + * \param tx_rx "tx" or "rx", depending where you're setting the subdev spec + * \param mb_i Mainboard index number. + * \param spec Subdev spec + */ + void update_subdev_spec(const std::string &tx_rx, const size_t mb_i, const uhd::usrp::subdev_spec_t &spec); void set_tick_rate(mboard_members_t &, const double); void update_tick_rate(mboard_members_t &, const double); diff --git a/host/lib/usrp/x300/x300_io_impl.cpp b/host/lib/usrp/x300/x300_io_impl.cpp index 603eb5704..9f4cdde7f 100644 --- a/host/lib/usrp/x300/x300_io_impl.cpp +++ b/host/lib/usrp/x300/x300_io_impl.cpp @@ -77,13 +77,14 @@ void x300_impl::update_tx_samp_rate(mboard_members_t &mb, const size_t dspno, co /*********************************************************************** * Setup dboard muxing for IQ **********************************************************************/ -void x300_impl::update_rx_subdev_spec(const size_t mb_i, const subdev_spec_t &spec) +void x300_impl::update_subdev_spec(const std::string &tx_rx, const size_t mb_i, const subdev_spec_t &spec) { + UHD_ASSERT_THROW(tx_rx == "tx" or tx_rx == "rx"); const std::string mb_name = boost::lexical_cast(mb_i); - fs_path root = "/mboards/"+mb_name+"/dboards"; + fs_path root = "/mboards/" + mb_name + "/dboards"; //sanity checking - validate_subdev_spec(_tree, spec, "rx", mb_name); + validate_subdev_spec(_tree, spec, tx_rx, mb_name); UHD_ASSERT_THROW(spec.size() <= 2); if (spec.size() > 0) UHD_ASSERT_THROW(spec[0].db_name == "A"); if (spec.size() > 1) UHD_ASSERT_THROW(spec[1].db_name == "B"); @@ -98,50 +99,24 @@ void x300_impl::update_rx_subdev_spec(const size_t mb_i, const subdev_spec_t &sp //extract fe name std::string fe_name; if (i < spec.size()) fe_name = spec[i].sd_name; - else fe_name = _tree->list(root / db_name / "rx_frontends").front(); + else fe_name = _tree->list(root / db_name / (tx_rx + "_frontends")).front(); //extract connection - const std::string conn = _tree->access(root / db_name / "rx_frontends" / fe_name / "connection").get(); - - //swap condition - const bool fe_swapped = (conn == "QI" or conn == "Q"); - _mb[mb_i].radio_perifs[i].ddc->set_mux(conn, fe_swapped); - //see usrp/io_impl.cpp if multiple DSPs share the frontend: - _mb[mb_i].radio_perifs[i].rx_fe->set_mux(fe_swapped); + const std::string conn = _tree->access(root / db_name / (tx_rx + "_frontends") / fe_name / "connection").get(); + + if (tx_rx == "tx") { + //swap condition + _mb[mb_i].radio_perifs[i].tx_fe->set_mux(conn); + } else { + //swap condition + const bool fe_swapped = (conn == "QI" or conn == "Q"); + _mb[mb_i].radio_perifs[i].ddc->set_mux(conn, fe_swapped); + //see usrp/io_impl.cpp if multiple DSPs share the frontend: + _mb[mb_i].radio_perifs[i].rx_fe->set_mux(fe_swapped); + } } } -void x300_impl::update_tx_subdev_spec(const size_t mb_i, const subdev_spec_t &spec) -{ - const std::string mb_name = boost::lexical_cast(mb_i); - fs_path root = "/mboards/"+mb_name+"/dboards"; - - //sanity checking - validate_subdev_spec(_tree, spec, "tx", mb_name); - UHD_ASSERT_THROW(spec.size() <= 2); - if (spec.size() > 0) UHD_ASSERT_THROW(spec[0].db_name == "A"); - if (spec.size() > 1) UHD_ASSERT_THROW(spec[1].db_name == "B"); - - //set the mux for this spec - for (size_t i = 0; i < 2; i++) - { - //extract db name - const std::string db_name = (i == 0)? "A" : "B"; - if (i < spec.size()) UHD_ASSERT_THROW(spec[i].db_name == db_name); - - //extract fe name - std::string fe_name; - if (i < spec.size()) fe_name = spec[i].sd_name; - else fe_name = _tree->list(root / db_name / "tx_frontends").front(); - - //extract connection - const std::string conn = _tree->access(root / db_name / "tx_frontends" / fe_name / "connection").get(); - - //swap condition - _mb[mb_i].radio_perifs[i].tx_fe->set_mux(conn); - - } -} /*********************************************************************** * VITA stuff -- cgit v1.2.3 From d9c0f278d1a445d0a9ddc1d3db548d45c9af0db8 Mon Sep 17 00:00:00 2001 From: Martin Braun Date: Fri, 21 Feb 2014 15:04:22 +0100 Subject: x300: added channel mapping capabilities --- host/lib/usrp/x300/x300_impl.cpp | 79 +++++++++++++++++++------------------ host/lib/usrp/x300/x300_impl.hpp | 30 +++++++++++--- host/lib/usrp/x300/x300_io_impl.cpp | 75 +++++++++++++++++++++-------------- 3 files changed, 111 insertions(+), 73 deletions(-) (limited to 'host/lib/usrp/x300/x300_io_impl.cpp') diff --git a/host/lib/usrp/x300/x300_impl.cpp b/host/lib/usrp/x300/x300_impl.cpp index 6a3ac5363..f0b5311c0 100644 --- a/host/lib/usrp/x300/x300_impl.cpp +++ b/host/lib/usrp/x300/x300_impl.cpp @@ -458,8 +458,6 @@ void x300_impl::setup_mb(const size_t mb_i, const uhd::device_addr_t &dev_addr) } } - const std::vector DB_NAMES = boost::assign::list_of("A")("B"); - //create basic communication UHD_MSG(status) << "Setup basic communication..." << std::endl; if (mb.xport_path == "nirio") { @@ -664,8 +662,8 @@ void x300_impl::setup_mb(const size_t mb_i, const uhd::device_addr_t &dev_addr) // setup radios //////////////////////////////////////////////////////////////////// UHD_MSG(status) << "Initialize Radio control..." << std::endl; - this->setup_radio(mb_i, 0, DB_NAMES[0]); - this->setup_radio(mb_i, 1, DB_NAMES[1]); + this->setup_radio(mb_i, "A"); + this->setup_radio(mb_i, "B"); //////////////////////////////////////////////////////////////////// // front panel gpio @@ -732,6 +730,9 @@ void x300_impl::setup_mb(const size_t mb_i, const uhd::device_addr_t &dev_addr) //////////////////////////////////////////////////////////////////// // create frontend mapping //////////////////////////////////////////////////////////////////// + std::vector default_map(2, 0); default_map[1] = 1; + _tree->create >(mb_path / "rx_chan_dsp_mapping").set(default_map); + _tree->create >(mb_path / "tx_chan_dsp_mapping").set(default_map); _tree->create(mb_path / "rx_subdev_spec") .subscribe(boost::bind(&x300_impl::update_subdev_spec, this, "rx", mb_i, _1)); _tree->create(mb_path / "tx_subdev_spec") @@ -824,20 +825,20 @@ static void check_adc(wb_iface::sptr iface, const boost::uint32_t val) UHD_ASSERT_THROW(adc_rb == val); } -void x300_impl::setup_radio(const size_t mb_i, const size_t i, const std::string &db_name) +void x300_impl::setup_radio(const size_t mb_i, const std::string &slot_name) { const fs_path mb_path = "/mboards/"+boost::lexical_cast(mb_i); + const size_t radio_index = _mb[mb_i].get_radio_index(slot_name); mboard_members_t &mb = _mb[mb_i]; - radio_perifs_t &perif = mb.radio_perifs[i]; - const size_t dspno = i; + radio_perifs_t &perif = mb.radio_perifs[radio_index]; //////////////////////////////////////////////////////////////////// // radio control //////////////////////////////////////////////////////////////////// - uint8_t dest = (i == 0)? X300_XB_DST_R0 : X300_XB_DST_R1; + uint8_t dest = (radio_index == 0)? X300_XB_DST_R0 : X300_XB_DST_R1; boost::uint32_t ctrl_sid; both_xports_t xport = this->make_transport(mb_i, dest, X300_RADIO_DEST_PREFIX_CTRL, device_addr_t(), ctrl_sid); - perif.ctrl = radio_ctrl_core_3000::make(mb.if_pkt_is_big_endian, xport.recv, xport.send, ctrl_sid, db_name); + perif.ctrl = radio_ctrl_core_3000::make(mb.if_pkt_is_big_endian, xport.recv, xport.send, ctrl_sid, slot_name); perif.ctrl->poke32(TOREG(SR_MISC_OUTS), (1 << 2)); //reset adc + dac perif.ctrl->poke32(TOREG(SR_MISC_OUTS), (1 << 1) | (1 << 0)); //out of reset + dac enable @@ -883,20 +884,20 @@ void x300_impl::setup_radio(const size_t mb_i, const size_t i, const std::string //////////////////////////////////////////////////////////////// // create codec control objects //////////////////////////////////////////////////////////////// - _tree->create(mb_path / "rx_codecs" / db_name / "gains"); //phony property so this dir exists - _tree->create(mb_path / "tx_codecs" / db_name / "gains"); //phony property so this dir exists - _tree->create(mb_path / "rx_codecs" / db_name / "name").set("ads62p48"); - _tree->create(mb_path / "tx_codecs" / db_name / "name").set("ad9146"); + _tree->create(mb_path / "rx_codecs" / slot_name / "gains"); //phony property so this dir exists + _tree->create(mb_path / "tx_codecs" / slot_name / "gains"); //phony property so this dir exists + _tree->create(mb_path / "rx_codecs" / slot_name / "name").set("ads62p48"); + _tree->create(mb_path / "tx_codecs" / slot_name / "name").set("ad9146"); - _tree->create(mb_path / "rx_codecs" / db_name / "gains" / "digital" / "range").set(meta_range_t(0, 6.0, 0.5)); - _tree->create(mb_path / "rx_codecs" / db_name / "gains" / "digital" / "value") + _tree->create(mb_path / "rx_codecs" / slot_name / "gains" / "digital" / "range").set(meta_range_t(0, 6.0, 0.5)); + _tree->create(mb_path / "rx_codecs" / slot_name / "gains" / "digital" / "value") .subscribe(boost::bind(&x300_adc_ctrl::set_gain, perif.adc, _1)).set(0); //////////////////////////////////////////////////////////////////// // front end corrections //////////////////////////////////////////////////////////////////// perif.rx_fe = rx_frontend_core_200::make(perif.ctrl, TOREG(SR_RX_FRONT)); - const fs_path rx_fe_path = mb_path / "rx_frontends" / db_name; + const fs_path rx_fe_path = mb_path / "rx_frontends" / slot_name; _tree->create >(rx_fe_path / "dc_offset" / "value") .coerce(boost::bind(&rx_frontend_core_200::set_dc_offset, perif.rx_fe, _1)) .set(std::complex(0.0, 0.0)); @@ -908,7 +909,7 @@ void x300_impl::setup_radio(const size_t mb_i, const size_t i, const std::string .set(std::complex(0.0, 0.0)); perif.tx_fe = tx_frontend_core_200::make(perif.ctrl, TOREG(SR_TX_FRONT)); - const fs_path tx_fe_path = mb_path / "tx_frontends" / db_name; + const fs_path tx_fe_path = mb_path / "tx_frontends" / slot_name; _tree->create >(tx_fe_path / "dc_offset" / "value") .coerce(boost::bind(&tx_frontend_core_200::set_dc_offset, perif.tx_fe, _1)) .set(std::complex(0.0, 0.0)); @@ -927,12 +928,12 @@ void x300_impl::setup_radio(const size_t mb_i, const size_t i, const std::string _tree->access(mb_path / "tick_rate") .subscribe(boost::bind(&rx_vita_core_3000::set_tick_rate, perif.framer, _1)) .subscribe(boost::bind(&rx_dsp_core_3000::set_tick_rate, perif.ddc, _1)); - const fs_path rx_dsp_path = mb_path / "rx_dsps" / str(boost::format("%u") % dspno); + const fs_path rx_dsp_path = mb_path / "rx_dsps" / str(boost::format("%u") % radio_index); _tree->create(rx_dsp_path / "rate" / "range") .publish(boost::bind(&rx_dsp_core_3000::get_host_rates, perif.ddc)); _tree->create(rx_dsp_path / "rate" / "value") .coerce(boost::bind(&rx_dsp_core_3000::set_host_rate, perif.ddc, _1)) - .subscribe(boost::bind(&x300_impl::update_rx_samp_rate, this, boost::ref(mb), dspno, _1)) + .subscribe(boost::bind(&x300_impl::update_rx_samp_rate, this, boost::ref(mb), radio_index, _1)) .set(1e6); _tree->create(rx_dsp_path / "freq" / "value") .coerce(boost::bind(&rx_dsp_core_3000::set_freq, perif.ddc, _1)) @@ -951,12 +952,12 @@ void x300_impl::setup_radio(const size_t mb_i, const size_t i, const std::string _tree->access(mb_path / "tick_rate") .subscribe(boost::bind(&tx_vita_core_3000::set_tick_rate, perif.deframer, _1)) .subscribe(boost::bind(&tx_dsp_core_3000::set_tick_rate, perif.duc, _1)); - const fs_path tx_dsp_path = mb_path / "tx_dsps" / str(boost::format("%u") % dspno); + const fs_path tx_dsp_path = mb_path / "tx_dsps" / str(boost::format("%u") % radio_index); _tree->create(tx_dsp_path / "rate" / "range") .publish(boost::bind(&tx_dsp_core_3000::get_host_rates, perif.duc)); _tree->create(tx_dsp_path / "rate" / "value") .coerce(boost::bind(&tx_dsp_core_3000::set_host_rate, perif.duc, _1)) - .subscribe(boost::bind(&x300_impl::update_tx_samp_rate, this, boost::ref(mb), dspno, _1)) + .subscribe(boost::bind(&x300_impl::update_tx_samp_rate, this, boost::ref(mb), radio_index, _1)) .set(1e6); _tree->create(tx_dsp_path / "freq" / "value") .coerce(boost::bind(&tx_dsp_core_3000::set_freq, perif.duc, _1)) @@ -975,14 +976,14 @@ void x300_impl::setup_radio(const size_t mb_i, const size_t i, const std::string //////////////////////////////////////////////////////////////////// // create RF frontend interfacing //////////////////////////////////////////////////////////////////// - const size_t j = (db_name == "B")? 0x2 : 0x0; - _tree->create(mb_path / "dboards" / db_name / "rx_eeprom") + const size_t j = (slot_name == "B")? 0x2 : 0x0; + _tree->create(mb_path / "dboards" / slot_name / "rx_eeprom") .set(mb.db_eeproms[X300_DB0_RX_EEPROM | j]) .subscribe(boost::bind(&x300_impl::set_db_eeprom, this, mb.zpu_i2c, (0x50 | X300_DB0_RX_EEPROM | j), _1)); - _tree->create(mb_path / "dboards" / db_name / "tx_eeprom") + _tree->create(mb_path / "dboards" / slot_name / "tx_eeprom") .set(mb.db_eeproms[X300_DB0_TX_EEPROM | j]) .subscribe(boost::bind(&x300_impl::set_db_eeprom, this, mb.zpu_i2c, (0x50 | X300_DB0_TX_EEPROM | j), _1)); - _tree->create(mb_path / "dboards" / db_name / "gdb_eeprom") + _tree->create(mb_path / "dboards" / slot_name / "gdb_eeprom") .set(mb.db_eeproms[X300_DB0_GDB_EEPROM | j]) .subscribe(boost::bind(&x300_impl::set_db_eeprom, this, mb.zpu_i2c, (0x50 | X300_DB0_GDB_EEPROM | j), _1)); @@ -994,33 +995,33 @@ void x300_impl::setup_radio(const size_t mb_i, const size_t i, const std::string db_config.tx_spi_slaveno = DB_TX_SEN; db_config.i2c = mb.zpu_i2c; db_config.clock = mb.clock; - db_config.which_rx_clk = (db_name == "A")? X300_CLOCK_WHICH_DB0_RX : X300_CLOCK_WHICH_DB1_RX; - db_config.which_tx_clk = (db_name == "A")? X300_CLOCK_WHICH_DB0_TX : X300_CLOCK_WHICH_DB1_TX; - db_config.dboard_slot = (db_name == "A")? 0 : 1; - _dboard_ifaces[db_name] = x300_make_dboard_iface(db_config); + db_config.which_rx_clk = (slot_name == "A")? X300_CLOCK_WHICH_DB0_RX : X300_CLOCK_WHICH_DB1_RX; + db_config.which_tx_clk = (slot_name == "A")? X300_CLOCK_WHICH_DB0_TX : X300_CLOCK_WHICH_DB1_TX; + db_config.dboard_slot = (slot_name == "A")? 0 : 1; + _dboard_ifaces[slot_name] = x300_make_dboard_iface(db_config); //create a new dboard manager - _tree->create(mb_path / "dboards" / db_name / "iface").set(_dboard_ifaces[db_name]); - _dboard_managers[db_name] = dboard_manager::make( + _tree->create(mb_path / "dboards" / slot_name / "iface").set(_dboard_ifaces[slot_name]); + _dboard_managers[slot_name] = dboard_manager::make( mb.db_eeproms[X300_DB0_RX_EEPROM | j].id, mb.db_eeproms[X300_DB0_TX_EEPROM | j].id, mb.db_eeproms[X300_DB0_GDB_EEPROM | j].id, - _dboard_ifaces[db_name], - _tree->subtree(mb_path / "dboards" / db_name) + _dboard_ifaces[slot_name], + _tree->subtree(mb_path / "dboards" / slot_name) ); //now that dboard is created -- register into rx antenna event - const std::string fe_name = _tree->list(mb_path / "dboards" / db_name / "rx_frontends").front(); - _tree->access(mb_path / "dboards" / db_name / "rx_frontends" / fe_name / "antenna" / "value") - .subscribe(boost::bind(&x300_impl::update_atr_leds, this, mb.radio_perifs[i].leds, _1)); - this->update_atr_leds(mb.radio_perifs[i].leds, ""); //init anyway, even if never called + const std::string fe_name = _tree->list(mb_path / "dboards" / slot_name / "rx_frontends").front(); + _tree->access(mb_path / "dboards" / slot_name / "rx_frontends" / fe_name / "antenna" / "value") + .subscribe(boost::bind(&x300_impl::update_atr_leds, this, mb.radio_perifs[radio_index].leds, _1)); + this->update_atr_leds(mb.radio_perifs[radio_index].leds, ""); //init anyway, even if never called //bind frontend corrections to the dboard freq props - const fs_path db_rx_fe_path = mb_path / "dboards" / db_name / "rx_frontends"; + const fs_path db_rx_fe_path = mb_path / "dboards" / slot_name / "rx_frontends"; BOOST_FOREACH(const std::string &name, _tree->list(db_rx_fe_path)) { _tree->access(db_rx_fe_path / name / "freq" / "value") - .subscribe(boost::bind(&x300_impl::set_rx_fe_corrections, this, mb_path, db_name, _1)); + .subscribe(boost::bind(&x300_impl::set_rx_fe_corrections, this, mb_path, slot_name, _1)); } } diff --git a/host/lib/usrp/x300/x300_impl.hpp b/host/lib/usrp/x300/x300_impl.hpp index ed8d29892..0fe63e4a5 100644 --- a/host/lib/usrp/x300/x300_impl.hpp +++ b/host/lib/usrp/x300/x300_impl.hpp @@ -82,8 +82,8 @@ static const double X300_DEFAULT_SYSREF_RATE = 10e6; #define X300_XB_DST_E0 0 #define X300_XB_DST_E1 1 -#define X300_XB_DST_R0 2 -#define X300_XB_DST_R1 3 +#define X300_XB_DST_R0 2 // Radio 0 -> Slot A +#define X300_XB_DST_R1 3 // Radio 1 -> Slot B #define X300_XB_DST_CE0 4 #define X300_XB_DST_CE1 5 #define X300_XB_DST_CE2 5 @@ -191,8 +191,13 @@ private: i2c_core_100_wb32::sptr zpu_i2c; //perifs in each radio - radio_perifs_t radio_perifs[2]; + radio_perifs_t radio_perifs[2]; //!< This is hardcoded s.t. radio_perifs[0] points to slot A and [1] to B uhd::usrp::dboard_eeprom_t db_eeproms[8]; + //! Return the index of a radio component, given a slot name. This means DSPs, radio_perifs + size_t get_radio_index(const std::string &slot_name) { + UHD_ASSERT_THROW(slot_name == "A" or slot_name == "B"); + return slot_name == "A" ? 0 : 1; + } //other perifs on mboard x300_clock_ctrl::sptr clock; @@ -218,7 +223,20 @@ private: void register_loopback_self_test(uhd::wb_iface::sptr iface); - void setup_radio(const size_t, const size_t which_radio, const std::string &db_name); + /*! \brief Initialize the radio component on a given slot. + * + * Call this function once per slot (A and B) and motherboard to initialize all the radio components. + * This will: + * - Reset and init DACs and ADCs + * - Setup controls for DAC, ADC, SPI and LEDs + * - Self test ADC + * - Sync DACs (for MIMO) + * - Initialize the property tree for control objects etc. (gain, rate...) + * + * \param mb_i Motherboard index + * \param slot_name Slot name (A or B). + */ + void setup_radio(const size_t, const std::string &slot_name); size_t _sid_framer; struct sid_config_t @@ -284,7 +302,9 @@ private: void set_rx_fe_corrections(const uhd::fs_path &mb_path, const std::string &fe_name, const double lo_freq); - /*! Update the IQ MUX settings for the radio peripheral according to given subdev spec + /*! Update the IQ MUX settings for the radio peripheral according to given subdev spec. + * + * Also checks if the given subdev is valid for this device and updates the channel to DSP mapping. * * \param tx_rx "tx" or "rx", depending where you're setting the subdev spec * \param mb_i Mainboard index number. diff --git a/host/lib/usrp/x300/x300_io_impl.cpp b/host/lib/usrp/x300/x300_io_impl.cpp index 9f4cdde7f..15556d197 100644 --- a/host/lib/usrp/x300/x300_io_impl.cpp +++ b/host/lib/usrp/x300/x300_io_impl.cpp @@ -80,41 +80,50 @@ void x300_impl::update_tx_samp_rate(mboard_members_t &mb, const size_t dspno, co void x300_impl::update_subdev_spec(const std::string &tx_rx, const size_t mb_i, const subdev_spec_t &spec) { UHD_ASSERT_THROW(tx_rx == "tx" or tx_rx == "rx"); + UHD_MSG(status) << "update_subdev_spec() " << tx_rx << std::endl; const std::string mb_name = boost::lexical_cast(mb_i); - fs_path root = "/mboards/" + mb_name + "/dboards"; + fs_path mb_root = "/mboards/" + mb_name; //sanity checking validate_subdev_spec(_tree, spec, tx_rx, mb_name); UHD_ASSERT_THROW(spec.size() <= 2); - if (spec.size() > 0) UHD_ASSERT_THROW(spec[0].db_name == "A"); - if (spec.size() > 1) UHD_ASSERT_THROW(spec[1].db_name == "B"); - - //setup mux for this spec - for (size_t i = 0; i < 2; i++) + if (spec.size() == 1) { + UHD_VAR(spec[0].db_name); + UHD_ASSERT_THROW(spec[0].db_name == "A" || spec[0].db_name == "B"); + } + if (spec.size() == 2) { + UHD_VAR(spec[0].db_name); + UHD_VAR(spec[1].db_name); + UHD_ASSERT_THROW( + (spec[0].db_name == "A" && spec[1].db_name == "B") || + (spec[0].db_name == "B" && spec[1].db_name == "A") + ); + } + + std::vector chan_to_dsp_map(spec.size(), 0); + // setup mux for this spec + for (size_t i = 0; i < spec.size(); i++) { - //extract db name - const std::string db_name = (i == 0)? "A" : "B"; - if (i < spec.size()) UHD_ASSERT_THROW(spec[i].db_name == db_name); - - //extract fe name - std::string fe_name; - if (i < spec.size()) fe_name = spec[i].sd_name; - else fe_name = _tree->list(root / db_name / (tx_rx + "_frontends")).front(); + const int radio_idx = _mb[mb_i].get_radio_index(spec[i].db_name); + chan_to_dsp_map[i] = radio_idx; //extract connection - const std::string conn = _tree->access(root / db_name / (tx_rx + "_frontends") / fe_name / "connection").get(); + const std::string conn = _tree->access(mb_root / "dboards" / spec[i].db_name / (tx_rx + "_frontends") / spec[i].sd_name / "connection").get(); if (tx_rx == "tx") { //swap condition - _mb[mb_i].radio_perifs[i].tx_fe->set_mux(conn); + _mb[mb_i].radio_perifs[radio_idx].tx_fe->set_mux(conn); } else { //swap condition const bool fe_swapped = (conn == "QI" or conn == "Q"); - _mb[mb_i].radio_perifs[i].ddc->set_mux(conn, fe_swapped); + _mb[mb_i].radio_perifs[radio_idx].ddc->set_mux(conn, fe_swapped); //see usrp/io_impl.cpp if multiple DSPs share the frontend: - _mb[mb_i].radio_perifs[i].rx_fe->set_mux(fe_swapped); + _mb[mb_i].radio_perifs[radio_idx].rx_fe->set_mux(fe_swapped); } } + + _tree->access >(mb_root / (tx_rx + "_chan_dsp_mapping")).set(chan_to_dsp_map); + UHD_MSG(status) << "-> return " << std::endl; } @@ -332,6 +341,7 @@ bool x300_impl::recv_async_msg( **********************************************************************/ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) { + UHD_MSG(status) << "get_rx_stream()" << std::endl; boost::mutex::scoped_lock lock(_transport_setup_mutex); stream_args_t args = args_; @@ -359,7 +369,10 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) } mboard_members_t &mb = _mb[mb_index]; - radio_perifs_t &perif = mb.radio_perifs[mb_chan]; + const size_t radio_index = _tree->access >("/mboards/" + boost::lexical_cast(mb_index) / "rx_chan_dsp_mapping") + .get().at(mb_chan); + UHD_VAR(radio_index); + radio_perifs_t &perif = mb.radio_perifs[radio_index]; //setup the dsp transport hints (default to a large recv buff) device_addr_t device_addr = mb.recv_args; @@ -380,7 +393,7 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) } //allocate sid and create transport - uint8_t dest = (mb_chan == 0)? X300_XB_DST_R0 : X300_XB_DST_R1; + uint8_t dest = (radio_index == 0)? X300_XB_DST_R0 : X300_XB_DST_R1; boost::uint32_t data_sid; UHD_LOG << "creating rx stream " << device_addr.to_string() << std::endl; both_xports_t xport = this->make_transport(mb_index, dest, X300_RADIO_DEST_PREFIX_RX, device_addr, data_sid); @@ -394,9 +407,9 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) - sizeof(vrt::if_packet_info_t().cid) //no class id ever used - sizeof(vrt::if_packet_info_t().tsi) //no int time ever used ; - const size_t bpp = xport.recv->get_recv_frame_size() - hdr_size; - const size_t bpi = convert::get_bytes_per_item(args.otw_format); - const size_t spp = unsigned(args.args.cast("spp", bpp/bpi)); + const size_t bpp = xport.recv->get_recv_frame_size() - hdr_size; // bytes per packet + const size_t bpi = convert::get_bytes_per_item(args.otw_format); // bytes per item + const size_t spp = unsigned(args.args.cast("spp", bpp/bpi)); // samples per packet //make the new streamer given the samples per packet if (not my_streamer) my_streamer = boost::make_shared(spp); @@ -463,14 +476,15 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) ); //Store a weak pointer to prevent a streamer->x300_impl->streamer circular dependency - mb.rx_streamers[mb_chan] = boost::weak_ptr(my_streamer); + mb.rx_streamers[radio_index] = boost::weak_ptr(my_streamer); //sets all tick and samp rates on this streamer const fs_path mb_path = "/mboards/"+boost::lexical_cast(mb_index); _tree->access(mb_path / "tick_rate").update(); - _tree->access(mb_path / "rx_dsps" / boost::lexical_cast(mb_chan) / "rate" / "value").update(); + _tree->access(mb_path / "rx_dsps" / boost::lexical_cast(radio_index) / "rate" / "value").update(); } + UHD_MSG(status) << "-> return (get_rx_stream)" << std::endl; return my_streamer; } @@ -510,6 +524,7 @@ void x300_impl::handle_overflow(x300_impl::radio_perifs_t &perif, boost::weak_pt **********************************************************************/ tx_streamer::sptr x300_impl::get_tx_stream(const uhd::stream_args_t &args_) { + UHD_MSG(status) << "get_tx_stream()" << std::endl; boost::mutex::scoped_lock lock(_transport_setup_mutex); stream_args_t args = args_; @@ -539,13 +554,15 @@ tx_streamer::sptr x300_impl::get_tx_stream(const uhd::stream_args_t &args_) } } mboard_members_t &mb = _mb[mb_index]; - radio_perifs_t &perif = mb.radio_perifs[mb_chan]; + const size_t radio_index = _tree->access >("/mboards/" + boost::lexical_cast(mb_index) / "tx_chan_dsp_mapping") + .get().at(mb_chan); + radio_perifs_t &perif = mb.radio_perifs[radio_index]; //setup the dsp transport hints (TODO) device_addr_t device_addr = mb.send_args; //allocate sid and create transport - uint8_t dest = (mb_chan == 0)? X300_XB_DST_R0 : X300_XB_DST_R1; + uint8_t dest = (radio_index == 0)? X300_XB_DST_R0 : X300_XB_DST_R1; boost::uint32_t data_sid; UHD_LOG << "creating tx stream " << device_addr.to_string() << std::endl; both_xports_t xport = this->make_transport(mb_index, dest, X300_RADIO_DEST_PREFIX_TX, device_addr, data_sid); @@ -618,12 +635,12 @@ tx_streamer::sptr x300_impl::get_tx_stream(const uhd::stream_args_t &args_) my_streamer->set_enable_trailer(false); //TODO not implemented trailer support yet //Store a weak pointer to prevent a streamer->x300_impl->streamer circular dependency - mb.tx_streamers[mb_chan] = boost::weak_ptr(my_streamer); + mb.tx_streamers[radio_index] = boost::weak_ptr(my_streamer); //sets all tick and samp rates on this streamer const fs_path mb_path = "/mboards/"+boost::lexical_cast(mb_index); _tree->access(mb_path / "tick_rate").update(); - _tree->access(mb_path / "tx_dsps" / boost::lexical_cast(mb_chan) / "rate" / "value").update(); + _tree->access(mb_path / "tx_dsps" / boost::lexical_cast(radio_index) / "rate" / "value").update(); } return my_streamer; -- cgit v1.2.3 From 7f24da588eecb327060f14e1c2404d42d8087f19 Mon Sep 17 00:00:00 2001 From: Martin Braun Date: Mon, 24 Feb 2014 13:08:13 +0100 Subject: Removed spurious UHD_VAR. --- host/lib/usrp/multi_usrp.cpp | 1 - host/lib/usrp/x300/x300_io_impl.cpp | 9 --------- 2 files changed, 10 deletions(-) (limited to 'host/lib/usrp/x300/x300_io_impl.cpp') diff --git a/host/lib/usrp/multi_usrp.cpp b/host/lib/usrp/multi_usrp.cpp index c01bd5785..e6e72ed3c 100644 --- a/host/lib/usrp/multi_usrp.cpp +++ b/host/lib/usrp/multi_usrp.cpp @@ -628,7 +628,6 @@ public: void set_rx_rate(double rate, size_t chan){ if (chan != ALL_CHANS){ - UHD_MSG(status) << "multi_usrp::set_rx_rate() rate=" << rate << " dsproot=" << rx_dsp_root(chan) << std::endl; _tree->access(rx_dsp_root(chan) / "rate" / "value").set(rate); do_samp_rate_warning_message(rate, get_rx_rate(chan), "RX"); return; diff --git a/host/lib/usrp/x300/x300_io_impl.cpp b/host/lib/usrp/x300/x300_io_impl.cpp index 15556d197..1b10e8001 100644 --- a/host/lib/usrp/x300/x300_io_impl.cpp +++ b/host/lib/usrp/x300/x300_io_impl.cpp @@ -80,7 +80,6 @@ void x300_impl::update_tx_samp_rate(mboard_members_t &mb, const size_t dspno, co void x300_impl::update_subdev_spec(const std::string &tx_rx, const size_t mb_i, const subdev_spec_t &spec) { UHD_ASSERT_THROW(tx_rx == "tx" or tx_rx == "rx"); - UHD_MSG(status) << "update_subdev_spec() " << tx_rx << std::endl; const std::string mb_name = boost::lexical_cast(mb_i); fs_path mb_root = "/mboards/" + mb_name; @@ -88,12 +87,9 @@ void x300_impl::update_subdev_spec(const std::string &tx_rx, const size_t mb_i, validate_subdev_spec(_tree, spec, tx_rx, mb_name); UHD_ASSERT_THROW(spec.size() <= 2); if (spec.size() == 1) { - UHD_VAR(spec[0].db_name); UHD_ASSERT_THROW(spec[0].db_name == "A" || spec[0].db_name == "B"); } if (spec.size() == 2) { - UHD_VAR(spec[0].db_name); - UHD_VAR(spec[1].db_name); UHD_ASSERT_THROW( (spec[0].db_name == "A" && spec[1].db_name == "B") || (spec[0].db_name == "B" && spec[1].db_name == "A") @@ -123,7 +119,6 @@ void x300_impl::update_subdev_spec(const std::string &tx_rx, const size_t mb_i, } _tree->access >(mb_root / (tx_rx + "_chan_dsp_mapping")).set(chan_to_dsp_map); - UHD_MSG(status) << "-> return " << std::endl; } @@ -341,7 +336,6 @@ bool x300_impl::recv_async_msg( **********************************************************************/ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) { - UHD_MSG(status) << "get_rx_stream()" << std::endl; boost::mutex::scoped_lock lock(_transport_setup_mutex); stream_args_t args = args_; @@ -371,7 +365,6 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) mboard_members_t &mb = _mb[mb_index]; const size_t radio_index = _tree->access >("/mboards/" + boost::lexical_cast(mb_index) / "rx_chan_dsp_mapping") .get().at(mb_chan); - UHD_VAR(radio_index); radio_perifs_t &perif = mb.radio_perifs[radio_index]; //setup the dsp transport hints (default to a large recv buff) @@ -484,7 +477,6 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) _tree->access(mb_path / "rx_dsps" / boost::lexical_cast(radio_index) / "rate" / "value").update(); } - UHD_MSG(status) << "-> return (get_rx_stream)" << std::endl; return my_streamer; } @@ -524,7 +516,6 @@ void x300_impl::handle_overflow(x300_impl::radio_perifs_t &perif, boost::weak_pt **********************************************************************/ tx_streamer::sptr x300_impl::get_tx_stream(const uhd::stream_args_t &args_) { - UHD_MSG(status) << "get_tx_stream()" << std::endl; boost::mutex::scoped_lock lock(_transport_setup_mutex); stream_args_t args = args_; -- cgit v1.2.3 From fa9e37dc0ad2f0b40d242289965438d498984bed Mon Sep 17 00:00:00 2001 From: Martin Braun Date: Mon, 10 Mar 2014 11:55:00 +0100 Subject: x300: Added comments on mb/chan search code --- host/lib/usrp/x300/x300_io_impl.cpp | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'host/lib/usrp/x300/x300_io_impl.cpp') diff --git a/host/lib/usrp/x300/x300_io_impl.cpp b/host/lib/usrp/x300/x300_io_impl.cpp index 1b10e8001..84f96d9f5 100644 --- a/host/lib/usrp/x300/x300_io_impl.cpp +++ b/host/lib/usrp/x300/x300_io_impl.cpp @@ -350,6 +350,7 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) boost::shared_ptr my_streamer; for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) { + // Find the mainboard and subdev that corresponds to channel args.channels[stream_i] const size_t chan = args.channels[stream_i]; size_t mb_chan = chan, mb_index; for (mb_index = 0; mb_index < _mb.size(); mb_index++) { @@ -362,6 +363,7 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) } } + // Find the DSP that corresponds to this mainboard and subdev mboard_members_t &mb = _mb[mb_index]; const size_t radio_index = _tree->access >("/mboards/" + boost::lexical_cast(mb_index) / "rx_chan_dsp_mapping") .get().at(mb_chan); @@ -533,6 +535,7 @@ tx_streamer::sptr x300_impl::get_tx_stream(const uhd::stream_args_t &args_) boost::shared_ptr my_streamer; for (size_t stream_i = 0; stream_i < args.channels.size(); stream_i++) { + // Find the mainboard and subdev that corresponds to channel args.channels[stream_i] const size_t chan = args.channels[stream_i]; size_t mb_chan = chan, mb_index; for (mb_index = 0; mb_index < _mb.size(); mb_index++) { @@ -544,6 +547,7 @@ tx_streamer::sptr x300_impl::get_tx_stream(const uhd::stream_args_t &args_) mb_chan -= curr_subdev_spec.size(); } } + // Find the DSP that corresponds to this mainboard and subdev mboard_members_t &mb = _mb[mb_index]; const size_t radio_index = _tree->access >("/mboards/" + boost::lexical_cast(mb_index) / "tx_chan_dsp_mapping") .get().at(mb_chan); -- cgit v1.2.3 From cbd800a252400bd0372e00974a02ed9d85e9d821 Mon Sep 17 00:00:00 2001 From: Martin Braun Date: Thu, 13 Mar 2014 17:38:16 +0100 Subject: uhd: Addressed Balints and Bens comments for subdev addressing --- host/lib/usrp/multi_usrp.cpp | 4 ++-- host/lib/usrp/x300/x300_impl.cpp | 3 ++- host/lib/usrp/x300/x300_io_impl.cpp | 33 +++++++++++++++++++-------------- 3 files changed, 23 insertions(+), 17 deletions(-) (limited to 'host/lib/usrp/x300/x300_io_impl.cpp') diff --git a/host/lib/usrp/multi_usrp.cpp b/host/lib/usrp/multi_usrp.cpp index 2e82e890e..f08709669 100644 --- a/host/lib/usrp/multi_usrp.cpp +++ b/host/lib/usrp/multi_usrp.cpp @@ -1063,7 +1063,7 @@ private: mboard_chan_pair mcp = rx_chan_to_mcp(chan); if (_tree->exists(mb_root(mcp.mboard) / "rx_chan_dsp_mapping")) { std::vector map = _tree->access >(mb_root(mcp.mboard) / "rx_chan_dsp_mapping").get(); - UHD_ASSERT_THROW(map.size() >= mcp.chan); + UHD_ASSERT_THROW(map.size() > mcp.chan); mcp.chan = map[mcp.chan]; } @@ -1083,7 +1083,7 @@ private: mboard_chan_pair mcp = tx_chan_to_mcp(chan); if (_tree->exists(mb_root(mcp.mboard) / "tx_chan_dsp_mapping")) { std::vector map = _tree->access >(mb_root(mcp.mboard) / "tx_chan_dsp_mapping").get(); - UHD_ASSERT_THROW(map.size() >= mcp.chan); + UHD_ASSERT_THROW(map.size() > mcp.chan); mcp.chan = map[mcp.chan]; } try diff --git a/host/lib/usrp/x300/x300_impl.cpp b/host/lib/usrp/x300/x300_impl.cpp index 22f607baa..e6dfa3bc1 100644 --- a/host/lib/usrp/x300/x300_impl.cpp +++ b/host/lib/usrp/x300/x300_impl.cpp @@ -829,8 +829,9 @@ static void check_adc(wb_iface::sptr iface, const boost::uint32_t val) void x300_impl::setup_radio(const size_t mb_i, const std::string &slot_name) { const fs_path mb_path = "/mboards/"+boost::lexical_cast(mb_i); - const size_t radio_index = _mb[mb_i].get_radio_index(slot_name); + UHD_ASSERT_THROW(mb_i < _mb.size()); mboard_members_t &mb = _mb[mb_i]; + const size_t radio_index = mb.get_radio_index(slot_name); radio_perifs_t &perif = mb.radio_perifs[radio_index]; //////////////////////////////////////////////////////////////////// diff --git a/host/lib/usrp/x300/x300_io_impl.cpp b/host/lib/usrp/x300/x300_io_impl.cpp index 84f96d9f5..85de34a54 100644 --- a/host/lib/usrp/x300/x300_io_impl.cpp +++ b/host/lib/usrp/x300/x300_io_impl.cpp @@ -80,6 +80,7 @@ void x300_impl::update_tx_samp_rate(mboard_members_t &mb, const size_t dspno, co void x300_impl::update_subdev_spec(const std::string &tx_rx, const size_t mb_i, const subdev_spec_t &spec) { UHD_ASSERT_THROW(tx_rx == "tx" or tx_rx == "rx"); + UHD_ASSERT_THROW(mb_i < _mb.size()); const std::string mb_name = boost::lexical_cast(mb_i); fs_path mb_root = "/mboards/" + mb_name; @@ -87,14 +88,14 @@ void x300_impl::update_subdev_spec(const std::string &tx_rx, const size_t mb_i, validate_subdev_spec(_tree, spec, tx_rx, mb_name); UHD_ASSERT_THROW(spec.size() <= 2); if (spec.size() == 1) { - UHD_ASSERT_THROW(spec[0].db_name == "A" || spec[0].db_name == "B"); - } - if (spec.size() == 2) { - UHD_ASSERT_THROW( - (spec[0].db_name == "A" && spec[1].db_name == "B") || - (spec[0].db_name == "B" && spec[1].db_name == "A") - ); - } + UHD_ASSERT_THROW(spec[0].db_name == "A" || spec[0].db_name == "B"); + } + else if (spec.size() == 2) { + UHD_ASSERT_THROW( + (spec[0].db_name == "A" && spec[1].db_name == "B") || + (spec[0].db_name == "B" && spec[1].db_name == "A") + ); + } std::vector chan_to_dsp_map(spec.size(), 0); // setup mux for this spec @@ -104,18 +105,18 @@ void x300_impl::update_subdev_spec(const std::string &tx_rx, const size_t mb_i, chan_to_dsp_map[i] = radio_idx; //extract connection - const std::string conn = _tree->access(mb_root / "dboards" / spec[i].db_name / (tx_rx + "_frontends") / spec[i].sd_name / "connection").get(); + const std::string conn = _tree->access(mb_root / "dboards" / spec[i].db_name / (tx_rx + "_frontends") / spec[i].sd_name / "connection").get(); - if (tx_rx == "tx") { + if (tx_rx == "tx") { //swap condition _mb[mb_i].radio_perifs[radio_idx].tx_fe->set_mux(conn); - } else { + } else { //swap condition const bool fe_swapped = (conn == "QI" or conn == "Q"); _mb[mb_i].radio_perifs[radio_idx].ddc->set_mux(conn, fe_swapped); //see usrp/io_impl.cpp if multiple DSPs share the frontend: _mb[mb_i].radio_perifs[radio_idx].rx_fe->set_mux(fe_swapped); - } + } } _tree->access >(mb_root / (tx_rx + "_chan_dsp_mapping")).set(chan_to_dsp_map); @@ -364,9 +365,13 @@ rx_streamer::sptr x300_impl::get_rx_stream(const uhd::stream_args_t &args_) } // Find the DSP that corresponds to this mainboard and subdev + UHD_ASSERT_THROW(mb_index < _mb.size()); mboard_members_t &mb = _mb[mb_index]; - const size_t radio_index = _tree->access >("/mboards/" + boost::lexical_cast(mb_index) / "rx_chan_dsp_mapping") - .get().at(mb_chan); + const std::vector dsp_map = _tree->access >("/mboards/" + boost::lexical_cast(mb_index) / "rx_chan_dsp_mapping") + .get(); //.at(mb_chan); + UHD_ASSERT_THROW(mb_chan < dsp_map.size()); + const size_t radio_index = dsp_map[mb_chan]; + UHD_ASSERT_THROW(radio_index < 2); radio_perifs_t &perif = mb.radio_perifs[radio_index]; //setup the dsp transport hints (default to a large recv buff) -- cgit v1.2.3