rfnoc: ctrl_iface cleanup

- ctrl_iface is now longer a wb_iface. All it can do now is send command
  packets, and receive responses to those.
- ctrl_iface does not store command time or tick rate
- wb_iface_adapter is no longer a set of functors, but a wrapper around
  ctrl_iface. Command times are stored once, in the block.
- DMA FIFO and radio block controllers have an easier time getting
  access to a timed_wb_iface

5 files changed, 154 insertions, 246 deletions

diff --git a/host/lib/rfnoc/block_ctrl_base.cpp b/host/lib/rfnoc/block_ctrl_base.cpp
index e842dabff..20d79d262 100644
--- a/host/lib/rfnoc/block_ctrl_base.cpp
+++ b/host/lib/rfnoc/block_ctrl_base.cpp
@@ -16,6 +16,7 @@
 #include <uhd/rfnoc/constants.hpp>
 #include <uhdlib/utils/compat_check.hpp>
 #include <uhdlib/rfnoc/ctrl_iface.hpp>
+#include <uhdlib/rfnoc/wb_iface_adapter.hpp>
 #include <boost/format.hpp>
 #include <boost/bind.hpp>
 
@@ -26,13 +27,6 @@ using namespace uhd::rfnoc;
 using std::string;
 
 /***********************************************************************
- * Helpers
- **********************************************************************/
-//! Convert register to a peek/poke compatible address
-inline uint32_t _sr_to_addr(const uint32_t reg) { return reg * 4; };
-inline uint32_t _sr_to_addr64(const uint32_t reg) { return reg * 8; }; // for peek64
-
-/***********************************************************************
  * Structors
  **********************************************************************/
 block_ctrl_base::block_ctrl_base(
@@ -82,6 +76,9 @@ block_ctrl_base::block_ctrl_base(
     /*** Configure ports ****************************************************/
     size_t n_valid_input_buffers = 0;
     for(const size_t ctrl_port:  get_ctrl_ports()) {
+        // Set command times to sensible defaults
+        set_command_tick_rate(1.0, ctrl_port);
+        set_command_time(time_spec_t(0.0), ctrl_port);
         // Set source addresses:
         sr_write(SR_BLOCK_SID, get_address(ctrl_port), ctrl_port);
         // Set sink buffer sizes:
@@ -208,16 +205,21 @@ void block_ctrl_base::_init_block_args()
 /***********************************************************************
  * FPGA control & communication
  **********************************************************************/
-wb_iface::sptr block_ctrl_base::get_ctrl_iface(const size_t block_port)
+timed_wb_iface::sptr block_ctrl_base::get_ctrl_iface(const size_t block_port)
 {
-    return _ctrl_ifaces[block_port];
+    return boost::make_shared<wb_iface_adapter>(
+        _ctrl_ifaces[block_port],
+        boost::bind(&block_ctrl_base::get_command_tick_rate, this, block_port),
+        boost::bind(&block_ctrl_base::set_command_time, this, _1, block_port),
+        boost::bind(&block_ctrl_base::get_command_time, this, block_port)
+    );
 }
 
 std::vector<size_t> block_ctrl_base::get_ctrl_ports() const
 {
     std::vector<size_t> ctrl_ports;
     ctrl_ports.reserve(_ctrl_ifaces.size());
-    std::pair<size_t, wb_iface::sptr> it;
+    std::pair<size_t, ctrl_iface::sptr> it;
     for(auto it:  _ctrl_ifaces) {
         ctrl_ports.push_back(it.first);
     }
@@ -232,7 +234,10 @@ void block_ctrl_base::sr_write(const uint32_t reg, const uint32_t data, const si
         throw uhd::key_error(str(boost::format("[%s] sr_write(): No such port: %d") % get_block_id().get() % port));
     }
     try {
-        _ctrl_ifaces[port]->poke32(_sr_to_addr(reg), data);
+        _ctrl_ifaces[port]->send_cmd_pkt(
+            reg, data, false,
+            _cmd_timespecs[port].to_ticks(_cmd_tickrates[port])
+        );
     }
     catch(const std::exception &ex) {
         throw uhd::io_error(str(boost::format("[%s] sr_write() failed: %s") % get_block_id().get() % ex.what()));
@@ -263,7 +268,11 @@ uint64_t block_ctrl_base::sr_read64(const settingsbus_reg_t reg, const size_t po
         throw uhd::key_error(str(boost::format("[%s] sr_read64(): No such port: %d") % get_block_id().get() % port));
     }
     try {
-        return _ctrl_ifaces[port]->peek64(_sr_to_addr64(reg));
+        return _ctrl_ifaces[port]->send_cmd_pkt(
+                SR_READBACK, reg,
+                true,
+                _cmd_timespecs[port].to_ticks(_cmd_tickrates[port])
+        );
     }
     catch(const std::exception &ex) {
         throw uhd::io_error(str(boost::format("[%s] sr_read64() failed: %s") % get_block_id().get() % ex.what()));
@@ -276,7 +285,11 @@ uint32_t block_ctrl_base::sr_read32(const settingsbus_reg_t reg, const size_t po
         throw uhd::key_error(str(boost::format("[%s] sr_read32(): No such port: %d") % get_block_id().get() % port));
     }
     try {
-        return _ctrl_ifaces[port]->peek32(_sr_to_addr64(reg));
+        return uint32_t(_ctrl_ifaces[port]->send_cmd_pkt(
+                SR_READBACK, reg,
+                true,
+                _cmd_timespecs[port].to_ticks(_cmd_tickrates[port])
+        ));
     }
     catch(const std::exception &ex) {
         throw uhd::io_error(str(boost::format("[%s] sr_read32() failed: %s") % get_block_id().get() % ex.what()));
@@ -286,6 +299,7 @@ uint32_t block_ctrl_base::sr_read32(const settingsbus_reg_t reg, const size_t po
 uint64_t block_ctrl_base::user_reg_read64(const uint32_t addr, const size_t port)
 {
     try {
+        // TODO: When timed readbacks are used, time the second, but not the first
         // Set readback register address
         sr_write(SR_READBACK_ADDR, addr, port);
         // Read readback register via RFNoC
@@ -345,32 +359,15 @@ void block_ctrl_base::set_command_time(
         }
         return;
     }
-    boost::shared_ptr<ctrl_iface> iface_sptr =
-        boost::dynamic_pointer_cast<ctrl_iface>(get_ctrl_iface(port));
-    if (not iface_sptr) {
-        throw uhd::assertion_error(str(
-            boost::format("[%s] Cannot set command time on port '%d'")
-            % unique_id() % port
-        ));
-    }
 
-    iface_sptr->set_time(time_spec);
+    _cmd_timespecs[port] = time_spec;
     _set_command_time(time_spec, port);
 }
 
 time_spec_t block_ctrl_base::get_command_time(
         const size_t port
 ) {
-    boost::shared_ptr<ctrl_iface> iface_sptr =
-        boost::dynamic_pointer_cast<ctrl_iface>(get_ctrl_iface(port));
-    if (not iface_sptr) {
-        throw uhd::assertion_error(str(
-            boost::format("[%s] Cannot get command time on port '%d'")
-            % unique_id() % port
-        ));
-    }
-
-    return iface_sptr->get_time();
+    return _cmd_timespecs[port];
 }
 
 void block_ctrl_base::set_command_tick_rate(
@@ -383,30 +380,18 @@ void block_ctrl_base::set_command_tick_rate(
         }
         return;
     }
-    boost::shared_ptr<ctrl_iface> iface_sptr =
-        boost::dynamic_pointer_cast<ctrl_iface>(get_ctrl_iface(port));
-    if (not iface_sptr) {
-        throw uhd::assertion_error(str(
-            boost::format("[%s] Cannot set command time on port '%d'")
-            % unique_id() % port
-        ));
-    }
 
-    iface_sptr->set_tick_rate(tick_rate);
+    _cmd_tickrates[port] = tick_rate;
 }
 
-void block_ctrl_base::clear_command_time(const size_t port)
+double block_ctrl_base::get_command_tick_rate(const size_t port)
 {
-    boost::shared_ptr<ctrl_iface> iface_sptr =
-        boost::dynamic_pointer_cast<ctrl_iface>(get_ctrl_iface(port));
-    if (not iface_sptr) {
-        throw uhd::assertion_error(str(
-            boost::format("[%s] Cannot set command time on port '%d'")
-            % unique_id() % port
-        ));
-    }
+    return _cmd_tickrates[port];
+}
 
-    iface_sptr->set_time(time_spec_t(0.0));
+void block_ctrl_base::clear_command_time(const size_t port)
+{
+    _cmd_timespecs[port] = time_spec_t(0.0);
 }
 
 void block_ctrl_base::clear()
diff --git a/host/lib/rfnoc/ctrl_iface.cpp b/host/lib/rfnoc/ctrl_iface.cpp
index 147f81e0c..9515cda0d 100644
--- a/host/lib/rfnoc/ctrl_iface.cpp
+++ b/host/lib/rfnoc/ctrl_iface.cpp
@@ -10,6 +10,7 @@
 #include <uhd/utils/safe_call.hpp>
 #include <uhd/transport/bounded_buffer.hpp>
 #include <uhd/types/sid.hpp>
+#include <uhd/types/endianness.hpp>
 #include <uhd/transport/chdr.hpp>
 #include <uhd/rfnoc/constants.hpp>
 #include <uhdlib/rfnoc/ctrl_iface.hpp>
@@ -17,6 +18,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/format.hpp>
 #include <boost/bind.hpp>
+#include <boost/make_shared.hpp>
 #include <queue>
 
 using namespace uhd;
@@ -30,89 +32,53 @@ ctrl_iface::~ctrl_iface(void){
     /* NOP */
 }
 
+template <uhd::endianness_t _endianness>
 class ctrl_iface_impl: public ctrl_iface
 {
 public:
 
-    ctrl_iface_impl(const bool big_endian,
-            uhd::transport::zero_copy_if::sptr ctrl_xport,
-            uhd::transport::zero_copy_if::sptr resp_xport,
-            const 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),
+    ctrl_iface_impl(
+            const both_xports_t &xports,
+            const std::string &name
+    ) : _xports(xports),
         _name(name),
         _seq_out(0),
-        _timeout(ACK_TIMEOUT),
-        _resp_queue_size(_resp_xport->get_num_recv_frames()),
-        _rb_address(uhd::rfnoc::SR_READBACK)
+        _max_outstanding_acks(
+            std::min(
+                uhd::rfnoc::CMD_FIFO_SIZE / 3, // Max command packet size is 3 lines
+                _xports.recv->get_num_recv_frames()
+            )
+        )
     {
-        UHD_ASSERT_THROW(_ctrl_xport);
-        UHD_ASSERT_THROW(_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
+        UHD_ASSERT_THROW(bool(_xports.send));
+        UHD_ASSERT_THROW(bool(_xports.recv));
+        // Flush the response transport in case we have something over:
+        while (_xports.recv->get_recv_buff(0.0)) {}
     }
 
     ~ctrl_iface_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
+            // dummy peek with the purpose of ack'ing all packets
+            this->send_cmd_pkt(0, 0, true);
         )
     }
 
     /*******************************************************************
-     * Peek and poke 32 bit implementation
-     ******************************************************************/
-    void poke32(const wb_addr_type addr, const uint32_t data)
-    {
-        boost::mutex::scoped_lock lock(_mutex);
-        this->send_pkt(addr/4, data);
-        this->wait_for_ack(false);
-    }
-
-    uint32_t peek32(const wb_addr_type addr)
-    {
-        boost::mutex::scoped_lock lock(_mutex);
-        this->send_pkt(_rb_address, addr/8);
-        const uint64_t res = this->wait_for_ack(true);
-        const uint32_t lo = uint32_t(res & 0xffffffff);
-        const uint32_t hi = uint32_t(res >> 32);
-        return ((addr/4) & 0x1)? hi : lo;
-    }
-
-    uint64_t peek64(const wb_addr_type addr)
-    {
-        boost::mutex::scoped_lock lock(_mutex);
-        this->send_pkt(_rb_address, addr/8);
-        return this->wait_for_ack(true);
-    }
-
-    /*******************************************************************
-     * Update methods for time
+     * Get and set register implementation
      ******************************************************************/
-    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)
-    {
+    uint64_t send_cmd_pkt(
+            const size_t addr,
+            const size_t data,
+            const bool readback,
+            const uint64_t timestamp=0
+    ) {
         boost::mutex::scoped_lock lock(_mutex);
-        return _time;
-    }
-
-    void set_tick_rate(const double rate)
-    {
-        boost::mutex::scoped_lock lock(_mutex);
-        _tick_rate = rate;
+        this->send_pkt(addr, data, timestamp);
+        return this->wait_for_ack(
+                readback,
+                bool(timestamp) ? MASSIVE_TIMEOUT : ACK_TIMEOUT
+        );
     }
 
 private:
@@ -125,9 +91,12 @@ private:
     /*******************************************************************
      * Primary control and interaction private methods
      ******************************************************************/
-    inline void send_pkt(const uint32_t addr, const uint32_t data = 0)
-    {
-        managed_send_buffer::sptr buff = _ctrl_xport->get_send_buff(0.0);
+    inline void send_pkt(
+            const uint32_t addr,
+            const uint32_t data,
+            const uint64_t timestamp
+    ) {
+        managed_send_buffer::sptr buff = _xports.send->get_send_buff(0.0);
         if (not buff) {
             throw uhd::runtime_error("fifo ctrl timed out getting a send buffer");
         }
@@ -135,29 +104,33 @@ private:
 
         //load packet info
         vrt::if_packet_info_t packet_info;
-        packet_info.link_type = _link_type;
-        packet_info.packet_type = _packet_type;
+        packet_info.link_type = vrt::if_packet_info_t::LINK_TYPE_CHDR;
+        packet_info.packet_type = vrt::if_packet_info_t::PACKET_TYPE_CMD;
         packet_info.num_payload_words32 = 2;
         packet_info.num_payload_bytes = packet_info.num_payload_words32*sizeof(uint32_t);
         packet_info.packet_count = _seq_out;
-        packet_info.tsf = _time.to_ticks(_tick_rate);
+        packet_info.tsf = timestamp;
         packet_info.sob = false;
         packet_info.eob = false;
-        packet_info.sid = _sid;
+        packet_info.sid = _xports.send_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_tsf = bool(timestamp);
         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);
+        // Unpack header and load payload
+        if (_endianness == uhd::ENDIANNESS_BIG) { // This if statement gets compiled out
+            vrt::if_hdr_pack_be(pkt, packet_info);
+            pkt[packet_info.num_header_words32+0] = uhd::htonx(addr);
+            pkt[packet_info.num_header_words32+1] = uhd::htonx(data);
+        } else {
+            vrt::if_hdr_pack_le(pkt, packet_info);
+            pkt[packet_info.num_header_words32+0] = uhd::htowx(addr);
+            pkt[packet_info.num_header_words32+1] = uhd::htowx(data);
+        }
 
-        //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_LOGGER_INFO("RFNOC") << boost::format("0x%08x, 0x%08x\n") % addr % data;
+        //UHD_LOGGER_TRACE("RFNOC") << boost::format("0x%08x, 0x%08x\n") % addr % data;
         //send the buffer over the interface
         _outstanding_seqs.push(_seq_out);
         buff->commit(sizeof(uint32_t)*(packet_info.num_packet_words32));
@@ -165,9 +138,9 @@ private:
         _seq_out++;//inc seq for next call
     }
 
-    UHD_INLINE uint64_t wait_for_ack(const bool readback)
+    inline uint64_t wait_for_ack(const bool readback, const double timeout)
     {
-        while (readback or (_outstanding_seqs.size() >= _resp_queue_size))
+        while (readback or (_outstanding_seqs.size() >= _max_outstanding_acks))
         {
             //get seq to ack from outstanding packets list
             UHD_ASSERT_THROW(not _outstanding_seqs.empty());
@@ -180,24 +153,29 @@ private:
             uint32_t const *pkt = NULL;
             managed_recv_buffer::sptr buff;
 
-            buff = _resp_xport->get_recv_buff(_timeout);
+            buff = _xports.recv->get_recv_buff(timeout);
             try {
                 UHD_ASSERT_THROW(bool(buff));
                 UHD_ASSERT_THROW(buff->size() > 0);
                 _outstanding_seqs.pop();
             }
             catch(const std::exception &ex) {
-                throw uhd::io_error(str(boost::format("Block ctrl (%s) no response packet - %s") % _name % ex.what()));
+                throw uhd::io_error(str(
+                    boost::format("Block ctrl (%s) no response packet - %s")
+                    % _name
+                    % ex.what()
+                ));
             }
             pkt = buff->cast<const uint32_t *>();
             packet_info.num_packet_words32 = buff->size()/sizeof(uint32_t);
 
             //parse the buffer
-            try
-            {
-                packet_info.link_type = _link_type;
-                if (_bige) vrt::chdr::if_hdr_unpack_be(pkt, packet_info);
-                else vrt::chdr::if_hdr_unpack_le(pkt, packet_info);
+            try {
+                if (_endianness == uhd::ENDIANNESS_BIG) {
+                    vrt::chdr::if_hdr_unpack_be(pkt, packet_info);
+                } else {
+                    vrt::chdr::if_hdr_unpack_le(pkt, packet_info);
+                }
             }
             catch(const std::exception &ex)
             {
@@ -214,14 +192,13 @@ private:
             }
 
             //check the buffer
-            try
-            {
+            try {
                 UHD_ASSERT_THROW(packet_info.has_sid);
-                if (packet_info.sid != uint32_t((_sid >> 16) | (_sid << 16))) {
+                if (packet_info.sid != _xports.recv_sid.get()) {
                     throw uhd::io_error(
                         str(
                             boost::format("Expected SID: %s  Received SID: %s")
-                            % uhd::sid_t(_sid).reversed().to_pp_string_hex()
+                            % _xports.recv_sid.to_pp_string_hex()
                             % uhd::sid_t(packet_info.sid).to_pp_string_hex()
                         )
                     );
@@ -239,18 +216,23 @@ private:
                 }
 
                 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("Block ctrl (%s) packet parse error - %s") % _name % ex.what()));
+            catch (const std::exception &ex) {
+                throw uhd::io_error(str(
+                    boost::format("Block ctrl (%s) packet parse error - %s")
+                    % _name
+                    % ex.what()
+                ));
             }
 
             //return the readback value
-            if (readback and _outstanding_seqs.empty())
-            {
-                const uint64_t hi = (_bige)? uhd::ntohx(pkt[packet_info.num_header_words32+0]) : uhd::wtohx(pkt[packet_info.num_header_words32+0]);
-                const uint64_t lo = (_bige)? uhd::ntohx(pkt[packet_info.num_header_words32+1]) : uhd::wtohx(pkt[packet_info.num_header_words32+1]);
+            if (readback and _outstanding_seqs.empty()) {
+                const uint64_t hi = (_endianness == uhd::ENDIANNESS_BIG) ?
+                    uhd::ntohx(pkt[packet_info.num_header_words32+0])
+                    : uhd::wtohx(pkt[packet_info.num_header_words32+0]);
+                const uint64_t lo = (_endianness == uhd::ENDIANNESS_BIG) ?
+                    uhd::ntohx(pkt[packet_info.num_header_words32+1])
+                    : uhd::wtohx(pkt[packet_info.num_header_words32+1]);
                 return ((hi << 32) | lo);
             }
         }
@@ -258,33 +240,28 @@ private:
         return 0;
     }
 
-    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;
-    const uint32_t _sid;
+
+    const uhd::both_xports_t _xports;
     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;
-    const size_t _resp_queue_size;
+    const size_t _max_outstanding_acks;
 
-    const size_t _rb_address;
+    boost::mutex _mutex;
 };
 
 ctrl_iface::sptr ctrl_iface::make(
-        const bool big_endian,
-        zero_copy_if::sptr ctrl_xport,
-        zero_copy_if::sptr resp_xport,
-        const uint32_t sid,
+        const both_xports_t &xports,
         const std::string &name
 ) {
-    return sptr(new ctrl_iface_impl(
-                big_endian, ctrl_xport, resp_xport, sid, name
-    ));
+    if (xports.endianness == uhd::ENDIANNESS_BIG) {
+        return boost::make_shared<ctrl_iface_impl<uhd::ENDIANNESS_BIG>>(
+            xports, name
+        );
+    } else {
+        return boost::make_shared<ctrl_iface_impl<uhd::ENDIANNESS_LITTLE>>(
+            xports, name
+        );
+    }
 }
+
diff --git a/host/lib/rfnoc/dma_fifo_block_ctrl_impl.cpp b/host/lib/rfnoc/dma_fifo_block_ctrl_impl.cpp
index cbbd59323..e27c20809 100644
--- a/host/lib/rfnoc/dma_fifo_block_ctrl_impl.cpp
+++ b/host/lib/rfnoc/dma_fifo_block_ctrl_impl.cpp
@@ -27,25 +27,7 @@ public:
     {
         _perifs.resize(get_input_ports().size());
         for(size_t i = 0; i < _perifs.size(); i++) {
-            _perifs[i].ctrl = boost::make_shared<wb_iface_adapter>(
-                // poke32 functor
-                boost::bind(
-                    static_cast< void (block_ctrl_base::*)(const uint32_t, const uint32_t, const size_t) >(&block_ctrl_base::sr_write),
-                    this, _1, _2, i
-                ),
-                // peek32 functor
-                boost::bind(
-                    static_cast< uint32_t (block_ctrl_base::*)(const uint32_t, const size_t) >(&block_ctrl_base::user_reg_read32),
-                    this,
-                    _1, i
-                ),
-                // peek64 functor
-                boost::bind(
-                    static_cast< uint64_t (block_ctrl_base::*)(const uint32_t, const size_t) >(&block_ctrl_base::user_reg_read64),
-                    this,
-                    _1, i
-                )
-            );
+            _perifs[i].ctrl = this->get_ctrl_iface(i);
             static const uint32_t USER_SR_BASE = 128*4;
             static const uint32_t USER_RB_BASE = 0;     //Don't care
             _perifs[i].base_addr = DEFAULT_SIZE*i;
diff --git a/host/lib/rfnoc/radio_ctrl_impl.cpp b/host/lib/rfnoc/radio_ctrl_impl.cpp
index fe8d51468..a151b2690 100644
--- a/host/lib/rfnoc/radio_ctrl_impl.cpp
+++ b/host/lib/rfnoc/radio_ctrl_impl.cpp
@@ -45,29 +45,7 @@ radio_ctrl_impl::radio_ctrl_impl() :
     /////////////////////////////////////////////////////////////////////////
     for (size_t i = 0; i < _get_num_radios(); i++) {
         _register_loopback_self_test(i);
-        _perifs[i].ctrl = boost::make_shared<wb_iface_adapter>(
-            // poke32 functor
-            [this, i](const uint32_t addr, const uint32_t data){
-                this->sr_write(addr, data, i);
-            },
-            // peek32 functor
-            [this, i](const uint32_t addr){
-                return this->user_reg_read32(addr, i);
-            },
-            // peek64 functor
-            [this, i](const uint32_t addr){
-                return this->user_reg_read64(addr, i);
-            },
-            // get_time functor
-            [this, i](){
-                return this->get_command_time(i);
-            },
-            // set_time functor
-            [this, i](const time_spec_t& time_spec){
-                this->set_command_time(time_spec, i);
-            }
-        );
-
+        _perifs[i].ctrl = this->get_ctrl_iface(i);
         // FIXME there's currently no way to set the underflow policy
 
         if (i == 0) {
diff --git a/host/lib/rfnoc/wb_iface_adapter.cpp b/host/lib/rfnoc/wb_iface_adapter.cpp
index 3b9202661..64b41d6d2 100644
--- a/host/lib/rfnoc/wb_iface_adapter.cpp
+++ b/host/lib/rfnoc/wb_iface_adapter.cpp
@@ -6,56 +6,42 @@
 //
 
 #include <uhdlib/rfnoc/wb_iface_adapter.hpp>
+#include <uhd/rfnoc/constants.hpp>
 
 using namespace uhd::rfnoc;
 
 wb_iface_adapter::wb_iface_adapter(
-        const poke32_type &poke32_functor_,
-        const peek32_type &peek32_functor_,
-        const peek64_type &peek64_functor_,
-        const gettime_type &gettime_functor_,
-        const settime_type &settime_functor_
-) : poke32_functor(poke32_functor_)
-  , peek32_functor(peek32_functor_)
-  , peek64_functor(peek64_functor_)
-  , gettime_functor(gettime_functor_)
+        ctrl_iface::sptr iface,
+        const gettickrate_type & gettickrate_functor_,
+        const settime_type & settime_functor_,
+        const gettime_type & gettime_functor_
+) : _iface(iface)
+  , gettickrate_functor(gettickrate_functor_)
   , settime_functor(settime_functor_)
-{
-    // nop
-}
-
-wb_iface_adapter::wb_iface_adapter(
-        const poke32_type &poke32_functor_,
-        const peek32_type &peek32_functor_,
-        const peek64_type &peek64_functor_
-) : poke32_functor(poke32_functor_)
-  , peek32_functor(peek32_functor_)
-  , peek64_functor(peek64_functor_)
+  , gettime_functor(gettime_functor_)
 {
     // nop
 }
 
 void wb_iface_adapter::poke32(const wb_addr_type addr, const uint32_t data)
 {
-    poke32_functor(addr / 4, data); // FIXME remove the requirement for /4
+    const uint64_t timestamp = gettime_functor().to_ticks(gettickrate_functor());
+    _iface->send_cmd_pkt(addr / 4, data, false, timestamp);
 }
 
 uint32_t wb_iface_adapter::peek32(const wb_addr_type addr)
 {
-    return peek32_functor(addr / 8);
+    const uint64_t reg_value = peek64(addr);
+    return ((addr/4) & 0x1) ?
+        uint32_t(reg_value >> 32) :
+        uint32_t(reg_value & 0xffffffff);
 }
 
 uint64_t wb_iface_adapter::peek64(const wb_addr_type addr)
 {
-    return peek64_functor(addr / 8);
-}
-
-uhd::time_spec_t wb_iface_adapter::get_time(void)
-{
-    return gettime_functor();
+    const uint64_t timestamp = gettime_functor().to_ticks(gettickrate_functor());
+    // TODO: Figure out if we should have a timestamp here
+    _iface->send_cmd_pkt(SR_READBACK_ADDR, addr / 8, false, timestamp);
+    return _iface->send_cmd_pkt(SR_READBACK, SR_READBACK_REG_USER, true, timestamp);
 }
 
-void wb_iface_adapter::set_time(const uhd::time_spec_t& t)
-{
-    settime_functor(t);
-}