From b9a80a76aa6117ad1ed865accc77004db24d0e42 Mon Sep 17 00:00:00 2001
From: Martin Braun <martin.braun@ettus.com>
Date: Fri, 19 Aug 2016 10:37:37 -0700
Subject: Revert "B200: Adding separate B200 radio control code"
This reverts commit 5d360ab43eca63e3f12f0e5abde5a3186b7f12dc.
---
host/lib/usrp/b200/CMakeLists.txt | 1 -
host/lib/usrp/b200/b200_impl.cpp | 12 +-
host/lib/usrp/b200/b200_impl.hpp | 10 +-
host/lib/usrp/b200/b200_io_impl.cpp | 2 +-
host/lib/usrp/b200/b200_radio_ctrl_core.cpp | 347 ----------------------------
host/lib/usrp/b200/b200_radio_ctrl_core.hpp | 64 -----
6 files changed, 12 insertions(+), 424 deletions(-)
delete mode 100644 host/lib/usrp/b200/b200_radio_ctrl_core.cpp
delete mode 100644 host/lib/usrp/b200/b200_radio_ctrl_core.hpp
(limited to 'host')
diff --git a/host/lib/usrp/b200/CMakeLists.txt b/host/lib/usrp/b200/CMakeLists.txt
index d953acb19..4b9e2de55 100644
--- a/host/lib/usrp/b200/CMakeLists.txt
+++ b/host/lib/usrp/b200/CMakeLists.txt
@@ -30,6 +30,5 @@ IF(ENABLE_B200)
${CMAKE_CURRENT_SOURCE_DIR}/b200_io_impl.cpp
${CMAKE_CURRENT_SOURCE_DIR}/b200_uart.cpp
${CMAKE_CURRENT_SOURCE_DIR}/b200_cores.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/b200_radio_ctrl_core.cpp
)
ENDIF(ENABLE_B200)
diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index 9526ae2d1..aed1204d3 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -466,7 +466,7 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s
////////////////////////////////////////////////////////////////////
// Local control endpoint
////////////////////////////////////////////////////////////////////
- _local_ctrl = b200_radio_ctrl_core::make(false/*lilE*/, _ctrl_transport, zero_copy_if::sptr()/*null*/, B200_LOCAL_CTRL_SID);
+ _local_ctrl = radio_ctrl_core_3000::make(false/*lilE*/, _ctrl_transport, zero_copy_if::sptr()/*null*/, B200_LOCAL_CTRL_SID);
_local_ctrl->hold_task(_async_task);
_async_task_data->local_ctrl = _local_ctrl; //weak
this->check_fpga_compat();
@@ -625,9 +625,9 @@ b200_impl::b200_impl(const uhd::device_addr_t& device_addr, usb_device_handle::s
{
_codec_mgr->loopback_self_test(
boost::bind(
- &b200_radio_ctrl_core::poke32, perif.ctrl, TOREG(SR_CODEC_IDLE), _1
+ &radio_ctrl_core_3000::poke32, perif.ctrl, TOREG(SR_CODEC_IDLE), _1
),
- boost::bind(&b200_radio_ctrl_core::peek64, perif.ctrl, RB64_CODEC_READBACK)
+ boost::bind(&radio_ctrl_core_3000::peek64, perif.ctrl, RB64_CODEC_READBACK)
);
}
@@ -756,7 +756,7 @@ void b200_impl::setup_radio(const size_t dspno)
////////////////////////////////////////////////////////////////////
// radio control
////////////////////////////////////////////////////////////////////
- perif.ctrl = b200_radio_ctrl_core::make(
+ perif.ctrl = radio_ctrl_core_3000::make(
false/*lilE*/,
_ctrl_transport,
zero_copy_if::sptr()/*null*/,
@@ -764,9 +764,9 @@ void b200_impl::setup_radio(const size_t dspno)
perif.ctrl->hold_task(_async_task);
_async_task_data->radio_ctrl[dspno] = perif.ctrl; //weak
_tree->access<time_spec_t>(mb_path / "time" / "cmd")
- .add_coerced_subscriber(boost::bind(&b200_radio_ctrl_core::set_time, perif.ctrl, _1));
+ .add_coerced_subscriber(boost::bind(&radio_ctrl_core_3000::set_time, perif.ctrl, _1));
_tree->access<double>(mb_path / "tick_rate")
- .add_coerced_subscriber(boost::bind(&b200_radio_ctrl_core::set_tick_rate, perif.ctrl, _1));
+ .add_coerced_subscriber(boost::bind(&radio_ctrl_core_3000::set_tick_rate, perif.ctrl, _1));
this->register_loopback_self_test(perif.ctrl);
////////////////////////////////////////////////////////////////////
diff --git a/host/lib/usrp/b200/b200_impl.hpp b/host/lib/usrp/b200/b200_impl.hpp
index 3ca76fce6..130e93891 100644
--- a/host/lib/usrp/b200/b200_impl.hpp
+++ b/host/lib/usrp/b200/b200_impl.hpp
@@ -28,7 +28,7 @@
#include "tx_vita_core_3000.hpp"
#include "time_core_3000.hpp"
#include "gpio_atr_3000.hpp"
-#include "b200_radio_ctrl_core.hpp"
+#include "radio_ctrl_core_3000.hpp"
#include "rx_dsp_core_3000.hpp"
#include "tx_dsp_core_3000.hpp"
#include <uhd/device.hpp>
@@ -131,7 +131,7 @@ private:
//controllers
b200_iface::sptr _iface;
- b200_radio_ctrl_core::sptr _local_ctrl;
+ radio_ctrl_core_3000::sptr _local_ctrl;
uhd::usrp::ad9361_ctrl::sptr _codec_ctrl;
uhd::usrp::ad936x_manager::sptr _codec_mgr;
b200_local_spi_core::sptr _spi_iface;
@@ -154,8 +154,8 @@ private:
struct AsyncTaskData
{
boost::shared_ptr<async_md_type> async_md;
- boost::weak_ptr<b200_radio_ctrl_core> local_ctrl;
- boost::weak_ptr<b200_radio_ctrl_core> radio_ctrl[2];
+ boost::weak_ptr<radio_ctrl_core_3000> local_ctrl;
+ boost::weak_ptr<radio_ctrl_core_3000> radio_ctrl[2];
b200_uart::sptr gpsdo_uart;
};
boost::shared_ptr<AsyncTaskData> _async_task_data;
@@ -179,7 +179,7 @@ private:
//perifs in the radio core
struct radio_perifs_t
{
- b200_radio_ctrl_core::sptr ctrl;
+ radio_ctrl_core_3000::sptr ctrl;
uhd::usrp::gpio_atr::gpio_atr_3000::sptr atr;
uhd::usrp::gpio_atr::gpio_atr_3000::sptr fp_gpio;
time_core_3000::sptr time64;
diff --git a/host/lib/usrp/b200/b200_io_impl.cpp b/host/lib/usrp/b200/b200_io_impl.cpp
index d186ec907..283091140 100644
--- a/host/lib/usrp/b200/b200_io_impl.cpp
+++ b/host/lib/usrp/b200/b200_io_impl.cpp
@@ -318,7 +318,7 @@ boost::optional<uhd::msg_task::msg_type_t> b200_impl::handle_async_task(
case B200_RESP1_MSG_SID:
case B200_LOCAL_RESP_SID:
{
- b200_radio_ctrl_core::sptr ctrl;
+ radio_ctrl_core_3000::sptr ctrl;
if (sid == B200_RESP0_MSG_SID) ctrl = data->radio_ctrl[0].lock();
if (sid == B200_RESP1_MSG_SID) ctrl = data->radio_ctrl[1].lock();
if (sid == B200_LOCAL_RESP_SID) ctrl = data->local_ctrl.lock();
diff --git a/host/lib/usrp/b200/b200_radio_ctrl_core.cpp b/host/lib/usrp/b200/b200_radio_ctrl_core.cpp
deleted file mode 100644
index b6d8f95df..000000000
--- a/host/lib/usrp/b200/b200_radio_ctrl_core.cpp
+++ /dev/null
@@ -1,347 +0,0 @@
-//
-// Copyright 2012-2015 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 <http://www.gnu.org/licenses/>.
-//
-
-#include "b200_radio_ctrl_core.hpp"
-#include "async_packet_handler.hpp"
-#include <uhd/exception.hpp>
-#include <uhd/utils/msg.hpp>
-#include <uhd/utils/byteswap.hpp>
-#include <uhd/utils/safe_call.hpp>
-#include <uhd/transport/bounded_buffer.hpp>
-#include <uhd/transport/vrt_if_packet.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/format.hpp>
-#include <boost/bind.hpp>
-#include <queue>
-
-using namespace uhd;
-using namespace uhd::usrp;
-using namespace uhd::transport;
-
-static const double ACK_TIMEOUT = 2.0; //supposed to be worst case practical timeout
-static const double MASSIVE_TIMEOUT = 10.0; //for when we wait on a timed command
-static const size_t SR_READBACK = 32;
-
-b200_radio_ctrl_core::~b200_radio_ctrl_core(void){
- /* NOP */
-}
-
-class b200_radio_ctrl_core_impl: public b200_radio_ctrl_core
-{
-public:
-
- b200_radio_ctrl_core_impl(const bool big_endian,
- uhd::transport::zero_copy_if::sptr ctrl_xport,
- uhd::transport::zero_copy_if::sptr resp_xport,
- const boost::uint32_t sid, const std::string &name) :
- _link_type(vrt::if_packet_info_t::LINK_TYPE_CHDR), _packet_type(
- vrt::if_packet_info_t::PACKET_TYPE_CONTEXT), _bige(
- big_endian), _ctrl_xport(ctrl_xport), _resp_xport(
- resp_xport), _sid(sid), _name(name), _seq_out(0), _timeout(
- ACK_TIMEOUT), _resp_queue(128/*max response msgs*/), _resp_queue_size(
- _resp_xport ? _resp_xport->get_num_recv_frames() : 15)
- {
- if (resp_xport)
- {
- while (resp_xport->get_recv_buff(0.0)) {} //flush
- }
- this->set_time(uhd::time_spec_t(0.0));
- this->set_tick_rate(1.0); //something possible but bogus
- }
-
- ~b200_radio_ctrl_core_impl(void)
- {
- _timeout = ACK_TIMEOUT; //reset timeout to something small
- UHD_SAFE_CALL(
- this->peek32(0);//dummy peek with the purpose of ack'ing all packets
- _async_task.reset();//now its ok to release the task
- )
- }
-
- /*******************************************************************
- * Peek and poke 32 bit implementation
- ******************************************************************/
- void poke32(const wb_addr_type addr, const boost::uint32_t data)
- {
- boost::mutex::scoped_lock lock(_mutex);
- this->send_pkt(addr/4, data);
- this->wait_for_ack(false);
- }
-
- boost::uint32_t peek32(const wb_addr_type addr)
- {
- boost::mutex::scoped_lock lock(_mutex);
- this->send_pkt(SR_READBACK, addr/8);
- const boost::uint64_t res = this->wait_for_ack(true);
- const boost::uint32_t lo = boost::uint32_t(res & 0xffffffff);
- const boost::uint32_t hi = boost::uint32_t(res >> 32);
- return ((addr/4) & 0x1)? hi : lo;
- }
-
- boost::uint64_t peek64(const wb_addr_type addr)
- {
- boost::mutex::scoped_lock lock(_mutex);
- this->send_pkt(SR_READBACK, addr/8);
- return this->wait_for_ack(true);
- }
-
- /*******************************************************************
- * Update methods for time
- ******************************************************************/
- void set_time(const uhd::time_spec_t &time)
- {
- boost::mutex::scoped_lock lock(_mutex);
- _time = time;
- _use_time = _time != uhd::time_spec_t(0.0);
- if (_use_time) _timeout = MASSIVE_TIMEOUT; //permanently sets larger timeout
- }
-
- uhd::time_spec_t get_time(void)
- {
- boost::mutex::scoped_lock lock(_mutex);
- return _time;
- }
-
- void set_tick_rate(const double rate)
- {
- boost::mutex::scoped_lock lock(_mutex);
- _tick_rate = rate;
- }
-
-private:
- // This is the buffer type for messages in radio control core.
- struct resp_buff_type
- {
- boost::uint32_t data[8];
- };
-
- /*******************************************************************
- * Primary control and interaction private methods
- ******************************************************************/
- UHD_INLINE void send_pkt(const boost::uint32_t addr, const boost::uint32_t data = 0)
- {
- managed_send_buffer::sptr buff = _ctrl_xport->get_send_buff(0.0);
- if (not buff) {
- throw uhd::runtime_error("fifo ctrl timed out getting a send buffer");
- }
- boost::uint32_t *pkt = buff->cast<boost::uint32_t *>();
-
- //load packet info
- vrt::if_packet_info_t packet_info;
- packet_info.link_type = _link_type;
- packet_info.packet_type = _packet_type;
- packet_info.num_payload_words32 = 2;
- packet_info.num_payload_bytes = packet_info.num_payload_words32*sizeof(boost::uint32_t);
- packet_info.packet_count = _seq_out;
- packet_info.tsf = _time.to_ticks(_tick_rate);
- 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 = _use_time;
- packet_info.has_tlr = false;
-
- //load header
- if (_bige) vrt::if_hdr_pack_be(pkt, packet_info);
- else vrt::if_hdr_pack_le(pkt, packet_info);
-
- //load payload
- pkt[packet_info.num_header_words32+0] = (_bige)? uhd::htonx(addr) : uhd::htowx(addr);
- pkt[packet_info.num_header_words32+1] = (_bige)? uhd::htonx(data) : uhd::htowx(data);
- //UHD_MSG(status) << boost::format("0x%08x, 0x%08x\n") % addr % data;
- //send the buffer over the interface
- _outstanding_seqs.push(_seq_out);
- buff->commit(sizeof(boost::uint32_t)*(packet_info.num_packet_words32));
-
- _seq_out++;//inc seq for next call
- }
-
- UHD_INLINE boost::uint64_t wait_for_ack(const bool readback)
- {
- while (readback or (_outstanding_seqs.size() >= _resp_queue_size))
- {
- //get seq to ack from outstanding packets list
- UHD_ASSERT_THROW(not _outstanding_seqs.empty());
- const size_t seq_to_ack = _outstanding_seqs.front();
- _outstanding_seqs.pop();
-
- //parse the packet
- vrt::if_packet_info_t packet_info;
- resp_buff_type resp_buff;
- memset(&resp_buff, 0x00, sizeof(resp_buff));
- boost::uint32_t const *pkt = NULL;
- managed_recv_buffer::sptr buff;
-
- //get buffer from response endpoint - or die in timeout
- if (_resp_xport)
- {
- buff = _resp_xport->get_recv_buff(_timeout);
- try
- {
- UHD_ASSERT_THROW(bool(buff));
- UHD_ASSERT_THROW(buff->size() > 0);
- }
- catch(const std::exception &ex)
- {
- throw uhd::io_error(str(boost::format("Radio ctrl (%s) no response packet - %s") % _name % ex.what()));
- }
- pkt = buff->cast<const boost::uint32_t *>();
- packet_info.num_packet_words32 = buff->size()/sizeof(boost::uint32_t);
- }
-
- //get buffer from response endpoint - or die in timeout
- else
- {
- /*
- * Couldn't get message with haste.
- * Now check both possible queues for messages.
- * Messages should come in on _resp_queue,
- * but could end up in dump_queue.
- * If we don't get a message --> Die in timeout.
- */
- double accum_timeout = 0.0;
- const double short_timeout = 0.005; // == 5ms
- while(not ((_resp_queue.pop_with_haste(resp_buff))
- || (check_dump_queue(resp_buff))
- || (_resp_queue.pop_with_timed_wait(resp_buff, short_timeout))
- )){
- /*
- * If a message couldn't be received within a given timeout
- * --> throw AssertionError!
- */
- accum_timeout += short_timeout;
- UHD_ASSERT_THROW(accum_timeout < _timeout);
- }
-
- pkt = resp_buff.data;
- packet_info.num_packet_words32 = sizeof(resp_buff)/sizeof(boost::uint32_t);
- }
-
- //parse the buffer
- try
- {
- packet_info.link_type = _link_type;
- if (_bige) vrt::if_hdr_unpack_be(pkt, packet_info);
- else vrt::if_hdr_unpack_le(pkt, packet_info);
- }
- catch(const std::exception &ex)
- {
- UHD_MSG(error) << "Radio ctrl bad VITA packet: " << ex.what() << std::endl;
- if (buff){
- UHD_VAR(buff->size());
- }
- else{
- UHD_MSG(status) << "buff is NULL" << std::endl;
- }
- UHD_MSG(status) << std::hex << pkt[0] << std::dec << std::endl;
- UHD_MSG(status) << std::hex << pkt[1] << std::dec << std::endl;
- UHD_MSG(status) << std::hex << pkt[2] << std::dec << std::endl;
- UHD_MSG(status) << std::hex << pkt[3] << std::dec << std::endl;
- }
-
- //check the buffer
- try
- {
- UHD_ASSERT_THROW(packet_info.has_sid);
- UHD_ASSERT_THROW(packet_info.sid == boost::uint32_t((_sid >> 16) | (_sid << 16)));
- UHD_ASSERT_THROW(packet_info.packet_count == (seq_to_ack & 0xfff));
- UHD_ASSERT_THROW(packet_info.num_payload_words32 == 2);
- UHD_ASSERT_THROW(packet_info.packet_type == _packet_type);
- }
- catch(const std::exception &ex)
- {
- throw uhd::io_error(str(boost::format("Radio ctrl (%s) packet parse error - %s") % _name % ex.what()));
- }
-
- //return the readback value
- if (readback and _outstanding_seqs.empty())
- {
- const boost::uint64_t hi = (_bige)? uhd::ntohx(pkt[packet_info.num_header_words32+0]) : uhd::wtohx(pkt[packet_info.num_header_words32+0]);
- const boost::uint64_t lo = (_bige)? uhd::ntohx(pkt[packet_info.num_header_words32+1]) : uhd::wtohx(pkt[packet_info.num_header_words32+1]);
- return ((hi << 32) | lo);
- }
- }
-
- return 0;
- }
-
- /*
- * If ctrl_core waits for a message that didn't arrive it can search for it in the dump queue.
- * This actually happens during shutdown.
- * handle_async_task can't access radio_ctrl_cores queue anymore thus it returns the corresponding message.
- * msg_task class implements a dump_queue to store such messages.
- * With check_dump_queue we can check if a message we are waiting for got stranded there.
- * If a message got stuck we get it here and push it onto our own message_queue.
- */
- bool check_dump_queue(resp_buff_type& b) {
- const size_t min_buff_size = 8; // Same value as in b200_io_impl->handle_async_task
- boost::uint32_t recv_sid = (((_sid)<<16)|((_sid)>>16));
- uhd::msg_task::msg_payload_t msg;
- do{
- msg = _async_task->get_msg_from_dump_queue(recv_sid);
- }
- while(msg.size() < min_buff_size && msg.size() != 0);
-
- if(msg.size() >= min_buff_size) {
- memcpy(b.data, &msg.front(), std::min(msg.size(), sizeof(b.data)));
- return true;
- }
- return false;
- }
-
- void push_response(const boost::uint32_t *buff)
- {
- resp_buff_type resp_buff;
- std::memcpy(resp_buff.data, buff, sizeof(resp_buff));
- _resp_queue.push_with_haste(resp_buff);
- }
-
- void hold_task(uhd::msg_task::sptr task)
- {
- _async_task = task;
- }
-
- const vrt::if_packet_info_t::link_type_t _link_type;
- const vrt::if_packet_info_t::packet_type_t _packet_type;
- const bool _bige;
- const uhd::transport::zero_copy_if::sptr _ctrl_xport;
- const uhd::transport::zero_copy_if::sptr _resp_xport;
- uhd::msg_task::sptr _async_task;
- const boost::uint32_t _sid;
- const std::string _name;
- boost::mutex _mutex;
- size_t _seq_out;
- uhd::time_spec_t _time;
- bool _use_time;
- double _tick_rate;
- double _timeout;
- std::queue<size_t> _outstanding_seqs;
- bounded_buffer<resp_buff_type> _resp_queue;
- const size_t _resp_queue_size;
-};
-
-b200_radio_ctrl_core::sptr b200_radio_ctrl_core::make(const bool big_endian,
- zero_copy_if::sptr ctrl_xport, zero_copy_if::sptr resp_xport,
- const boost::uint32_t sid, const std::string &name)
-{
- return sptr(
- new b200_radio_ctrl_core_impl(big_endian, ctrl_xport, resp_xport,
- sid, name));
-}
diff --git a/host/lib/usrp/b200/b200_radio_ctrl_core.hpp b/host/lib/usrp/b200/b200_radio_ctrl_core.hpp
deleted file mode 100644
index 51f7e3301..000000000
--- a/host/lib/usrp/b200/b200_radio_ctrl_core.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// Copyright 2012-2015 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 <http://www.gnu.org/licenses/>.
-//
-
-#ifndef INCLUDED_LIBUHD_USRP_B200_RADIO_CTRL_HPP
-#define INCLUDED_LIBUHD_USRP_B200_RADIO_CTRL_HPP
-
-#include <uhd/utils/msg_task.hpp>
-#include <uhd/types/time_spec.hpp>
-#include <uhd/transport/zero_copy.hpp>
-#include <uhd/types/wb_iface.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/utility.hpp>
-#include <string>
-
-/*!
- * Provide access to peek, poke for the radio ctrl module
- */
-class b200_radio_ctrl_core : public uhd::timed_wb_iface
-{
-public:
- typedef boost::shared_ptr<b200_radio_ctrl_core> sptr;
-
- virtual ~b200_radio_ctrl_core(void) = 0;
-
- //! Make a new control object
- static sptr make(
- const bool big_endian,
- uhd::transport::zero_copy_if::sptr ctrl_xport,
- uhd::transport::zero_copy_if::sptr resp_xport,
- const boost::uint32_t sid,
- const std::string &name = "0"
- );
-
- //! Hold a ref to a task thats feeding push response
- virtual void hold_task(uhd::msg_task::sptr task) = 0;
-
- //! Push a response externall (resp_xport is NULL)
- virtual void push_response(const boost::uint32_t *buff) = 0;
-
- //! Set the command time that will activate
- virtual void set_time(const uhd::time_spec_t &time) = 0;
-
- //! Get the command time that will activate
- virtual uhd::time_spec_t get_time(void) = 0;
-
- //! Set the tick rate (converting time into ticks)
- virtual void set_tick_rate(const double rate) = 0;
-};
-
-#endif /* INCLUDED_LIBUHD_USRP_B200_RADIO_CTRL_HPP */
--
cgit v1.2.3