Merge branch 'maint'

8 files changed, 76 insertions, 62 deletions

diff --git a/host/lib/usrp/common/adf5355.cpp b/host/lib/usrp/common/adf5355.cpp
index ee9d1d1d9..e3fd66bc2 100644
--- a/host/lib/usrp/common/adf5355.cpp
+++ b/host/lib/usrp/common/adf5355.cpp
@@ -62,43 +62,14 @@ public:
         _pfd_freq(0.0),
         _fb_after_divider(false)
     {
-        _regs.counter_reset = adf5355_regs_t::COUNTER_RESET_DISABLED;
-        _regs.cp_three_state = adf5355_regs_t::CP_THREE_STATE_DISABLED;
-        _regs.power_down = adf5355_regs_t::POWER_DOWN_DISABLED;
-        _regs.pd_polarity = adf5355_regs_t::PD_POLARITY_POSITIVE;
-        _regs.mux_logic = adf5355_regs_t::MUX_LOGIC_3_3V;
-        _regs.ref_mode = adf5355_regs_t::REF_MODE_SINGLE;
-        _regs.muxout = adf5355_regs_t::MUXOUT_DLD;
-        _regs.double_buff_div = adf5355_regs_t::DOUBLE_BUFF_DIV_DISABLED;
-
-        _regs.rf_out_a_enabled = adf5355_regs_t::RF_OUT_A_ENABLED_ENABLED;
-        _regs.rf_out_b_enabled = adf5355_regs_t::RF_OUT_B_ENABLED_DISABLED;
-        _regs.mute_till_lock_detect = adf5355_regs_t::MUTE_TILL_LOCK_DETECT_MUTE_DISABLED;
-        _regs.ld_mode = adf5355_regs_t::LD_MODE_FRAC_N;
-        _regs.frac_n_ld_precision = adf5355_regs_t::FRAC_N_LD_PRECISION_5NS;
-        _regs.ld_cyc_count = adf5355_regs_t::LD_CYC_COUNT_1024;
-        _regs.le_sync = adf5355_regs_t::LE_SYNC_LE_SYNCED_TO_REFIN;
-        _regs.phase_resync = adf5355_regs_t::PHASE_RESYNC_DISABLED;
-        _regs.reference_divide_by_2 = adf5355_regs_t::REFERENCE_DIVIDE_BY_2_DISABLED;
-        _regs.reference_doubler = adf5355_regs_t::REFERENCE_DOUBLER_DISABLED;
 
-        _regs.autocal_en = adf5355_regs_t::AUTOCAL_EN_ENABLED;
-        _regs.prescaler = adf5355_regs_t::PRESCALER_4_5;
+        // TODO This is a hardware specific value, but can be made the default in the ic_reg_map
         _regs.charge_pump_current = adf5355_regs_t::CHARGE_PUMP_CURRENT_0_94MA;
 
-        _regs.gated_bleed = adf5355_regs_t::GATED_BLEED_DISABLED;
-        _regs.negative_bleed = adf5355_regs_t::NEGATIVE_BLEED_ENABLED;
-        _regs.feedback_select = adf5355_regs_t::FEEDBACK_SELECT_FUNDAMENTAL;
-        _regs.output_power = adf5355_regs_t::OUTPUT_POWER_5DBM;
+        // TODO cleanup these magic numbers
         _regs.cp_bleed_current = 2;
         _regs.r_counter_10_bit = 8;
 
-
-        _regs.ld_cyc_count = adf5355_regs_t::LD_CYC_COUNT_1024;
-        _regs.loss_of_lock_mode = adf5355_regs_t::LOSS_OF_LOCK_MODE_DISABLED;
-        _regs.frac_n_ld_precision = adf5355_regs_t::FRAC_N_LD_PRECISION_5NS;
-        _regs.ld_mode = adf5355_regs_t::LD_MODE_FRAC_N;
-
         _regs.vco_band_div = 3;
         _regs.timeout = 11;
         _regs.auto_level_timeout = 30;
@@ -108,6 +79,14 @@ public:
         _regs.adc_conversion = adf5355_regs_t::ADC_CONVERSION_ENABLED;
         _regs.adc_enable = adf5355_regs_t::ADC_ENABLE_ENABLED;
 
+
+        // TODO Needs to be enabled for phase resync
+        _regs.phase_resync = adf5355_regs_t::PHASE_RESYNC_DISABLED;
+
+        // TODO Default should be divided, but there seems to be a bug preventing that. Needs rechecking
+        _regs.feedback_select = adf5355_regs_t::FEEDBACK_SELECT_FUNDAMENTAL;
+        
+        // TODO 0 is an invalid value for this field. Setting to 1 seemed to break phase sync, needs retesting.
         _regs.phase_resync_clk_div = 0;
     }
 
@@ -193,7 +172,9 @@ public:
 
         //-----------------------------------------------------------
         //Phase resync
-        _regs.phase_resync = adf5355_regs_t::PHASE_RESYNC_DISABLED; // Disabled during development
+        // TODO Renable here, in initialization, or through separate set_phase_resync(bool enable) function
+        _regs.phase_resync = adf5355_regs_t::PHASE_RESYNC_DISABLED;
+
         _regs.phase_adjust = adf5355_regs_t::PHASE_ADJUST_DISABLED;
         _regs.sd_load_reset = adf5355_regs_t::SD_LOAD_RESET_ON_REG0_UPDATE;
         _regs.phase_resync_clk_div = static_cast<uint16_t>(
diff --git a/host/lib/usrp/dboard/twinrx/twinrx_ctrl.cpp b/host/lib/usrp/dboard/twinrx/twinrx_ctrl.cpp
index dfbea9917..346f39589 100644
--- a/host/lib/usrp/dboard/twinrx/twinrx_ctrl.cpp
+++ b/host/lib/usrp/dboard/twinrx/twinrx_ctrl.cpp
@@ -106,6 +106,8 @@ public:
             _config_lo2_route(i==0?LO_CONFIG_CH1:LO_CONFIG_CH2);
             _lo1_iface[i]->set_output_power(adf5355_iface::OUTPUT_POWER_5DBM);
             _lo1_iface[i]->set_reference_freq(TWINRX_DESIRED_REFERENCE_FREQ);
+            // Divided feedback did not appear to be correctly implemented during bringup. Necessary for phase resync
+//            _lo1_iface[i]->set_feedback_select(adf5355_iface::FB_SEL_DIVIDED);
             _lo1_iface[i]->set_muxout_mode(adf5355_iface::MUXOUT_DLD);
             _lo1_iface[i]->set_frequency(3e9, 1.0e3);
             _lo2_iface[i]->set_feedback_select(adf435x_iface::FB_SEL_DIVIDED);
diff --git a/host/lib/usrp/device3/device3_io_impl.cpp b/host/lib/usrp/device3/device3_io_impl.cpp
index bb98b1031..2f2e778c9 100644
--- a/host/lib/usrp/device3/device3_io_impl.cpp
+++ b/host/lib/usrp/device3/device3_io_impl.cpp
@@ -808,6 +808,7 @@ tx_streamer::sptr device3_impl::get_tx_stream(const uhd::stream_args_t &args_)
                 )
         );
 
+        blk_ctrl->sr_write(uhd::rfnoc::SR_CLEAR_RX_FC, 0xc1ea12, block_port);
         blk_ctrl->sr_write(uhd::rfnoc::SR_RESP_IN_DST_SID, xport.recv_sid.get_dst(), block_port);
         UHD_STREAMER_LOG() << "[TX Streamer] resp_in_dst_sid == " << boost::format("0x%04X") % xport.recv_sid.get_dst() << std::endl;
 
diff --git a/host/lib/usrp/gps_ctrl.cpp b/host/lib/usrp/gps_ctrl.cpp
index 28f5a28cd..f4a42af34 100644
--- a/host/lib/usrp/gps_ctrl.cpp
+++ b/host/lib/usrp/gps_ctrl.cpp
@@ -92,7 +92,7 @@ private:
                     sentences[which].get<2>() = true;
                 }
             } catch(std::exception &e) {
-                UHD_MSG(warning) << "get_sentence: " << e.what();
+                UHD_LOGV(often) << "get_sentence: " << e.what();
             }
 
             if (not sentence.empty() or now > exit_time)
@@ -134,7 +134,7 @@ private:
     }
 
   void update_cache() {
-    if(not gps_detected() or (_gps_type != GPS_TYPE_INTERNAL_GPSDO)) {
+    if(not gps_detected()) {
         return;
     }
 
@@ -352,11 +352,11 @@ private:
             return gps_time;
 
         } catch(std::exception &e) {
-            UHD_MSG(warning) << "get_time: " << e.what();
+            UHD_LOGV(often) << "get_time: " << e.what();
             error_cnt++;
         }
     }
-    throw uhd::value_error("Timeout after no valid message found");
+    throw uhd::value_error("get_time: Timeout after no valid message found");
 
     return gps_time; //keep gcc from complaining
   }
@@ -379,7 +379,7 @@ private:
             else
                 return (get_token(reply, 6) != "0");
         } catch(std::exception &e) {
-            UHD_MSG(warning) << "locked: " << e.what();
+            UHD_LOGV(often) << "locked: " << e.what();
             error_cnt++;
         }
     }
diff --git a/host/lib/usrp/x300/x300_fw_uart.cpp b/host/lib/usrp/x300/x300_fw_uart.cpp
index 6e7425c4d..a2cbcc908 100644
--- a/host/lib/usrp/x300/x300_fw_uart.cpp
+++ b/host/lib/usrp/x300/x300_fw_uart.cpp
@@ -76,8 +76,9 @@ struct x300_uart_iface : uart_iface
         if (rxoffset == _last_device_rxoffset)
             return -1;
 
+        int ret = static_cast<int>(_rxcache[((rxoffset)/4) % poolsize] >> ((rxoffset%4)*8) & 0xFF);
         rxoffset++;
-        return static_cast<int>(_rxcache[(rxoffset/4) % poolsize] >> ((rxoffset%4)*8) & 0xFF);
+        return ret;
     }
 
     void update_cache(void)
@@ -91,30 +92,42 @@ struct x300_uart_iface : uart_iface
             {
                 // all the data is new - reload the entire cache
                 for (uint32_t i = 0; i < poolsize; i++)
+                {
                     _rxcache[i] = _iface->peek32(SR_ADDR(rxpool, i));
+                }
+
+                // set the head to the same character as the current device
+                // offset (tail) one loop earlier
+                rxoffset = device_rxoffset - (poolsize*4);
+
+                // set the tail to the current device offset
+                _last_device_rxoffset = device_rxoffset;
 
-                // set rxoffset to the end of the first string
-                rxoffset = device_rxoffset - (poolsize*4) + 1;
-                while (static_cast<char>((_rxcache[(rxoffset/4) % poolsize] >> ((rxoffset%4)*8) & 0xFF)) != '\n')
-                    ++rxoffset;
+                // the string at the head is a partial, so skip it
+                for (int c = getchar(); c != '\n' and c != -1; c = getchar()) {}
 
-                // clear the partial string in the buffer;
+                // clear the partial string in the buffer, if any
                 _rxbuff.clear();
             }
             else if (rxoffset == _last_device_rxoffset)
             {
                 // new data was added - refresh the portion of the cache that was updated
-                for (uint32_t i = ((_last_device_rxoffset+1)/4) % poolsize; i != (((device_rxoffset)/4)+1) % poolsize; i = (i+1) % poolsize)
+                for (uint32_t i = (_last_device_rxoffset/4) % poolsize;
+                        i != ((device_rxoffset/4)+1) % poolsize;
+                        i = (i+1) % poolsize)
                 {
                     _rxcache[i] = _iface->peek32(SR_ADDR(rxpool, i));
                 }
-            } else {
+
+                // set the tail to the current device offset
+                _last_device_rxoffset = device_rxoffset;
+            }
+            else
+            {
                 // there is new data, but we aren't done with what we have - check back later
                 break;
             }
 
-            _last_device_rxoffset = device_rxoffset;
-
             // check again to see if anything changed while we were updating the cache
             device_rxoffset = _iface->peek32(SR_ADDR(X300_FW_SHMEM_BASE, X300_FW_SHMEM_UART_RX_INDEX));
             delta = device_rxoffset - rxoffset;
diff --git a/host/lib/usrp/x300/x300_impl.cpp b/host/lib/usrp/x300/x300_impl.cpp
index 8164c79b6..aa54c2228 100644
--- a/host/lib/usrp/x300/x300_impl.cpp
+++ b/host/lib/usrp/x300/x300_impl.cpp
@@ -1529,13 +1529,32 @@ void x300_impl::claimer_loop(wb_iface::sptr iface)
 
 x300_impl::claim_status_t x300_impl::claim_status(wb_iface::sptr iface)
 {
-    //If timed out, then device is definitely unclaimed
-    if (iface->peek32(X300_FW_SHMEM_ADDR(X300_FW_SHMEM_CLAIM_STATUS)) == 0)
-        return UNCLAIMED;
+    claim_status_t claim_status = CLAIMED_BY_OTHER; // Default to most restrictive
+    boost::system_time timeout_time = boost::get_system_time() + boost::posix_time::seconds(1);
+    while (boost::get_system_time() < timeout_time)
+    {
+        //If timed out, then device is definitely unclaimed
+        if (iface->peek32(X300_FW_SHMEM_ADDR(X300_FW_SHMEM_CLAIM_STATUS)) == 0)
+        {
+            claim_status = UNCLAIMED;
+            break;
+        }
 
-    //otherwise check claim src to determine if another thread with the same src has claimed the device
-    uint32_t hash = iface->peek32(X300_FW_SHMEM_ADDR(X300_FW_SHMEM_CLAIM_SRC));
-    return (hash == get_process_hash() ? CLAIMED_BY_US : CLAIMED_BY_OTHER);
+        //otherwise check claim src to determine if another thread with the same src has claimed the device
+        uint32_t hash = iface->peek32(X300_FW_SHMEM_ADDR(X300_FW_SHMEM_CLAIM_SRC));
+        if (hash == 0)
+        {
+            // A non-zero claim status and an empty hash means the claim might
+            // be in the process of being released.  This is possible because
+            // older firmware takes a long time to update the status.  Wait and
+            // check status again.
+            boost::this_thread::sleep(boost::posix_time::milliseconds(5));
+            continue;
+        }
+        claim_status = (hash == get_process_hash() ? CLAIMED_BY_US : CLAIMED_BY_OTHER);
+        break;
+    }
+    return claim_status;
 }
 
 void x300_impl::claim(wb_iface::sptr iface)
diff --git a/host/lib/usrp/x300/x300_impl.hpp b/host/lib/usrp/x300/x300_impl.hpp
index 55b055d44..d082ab76a 100644
--- a/host/lib/usrp/x300/x300_impl.hpp
+++ b/host/lib/usrp/x300/x300_impl.hpp
@@ -54,10 +54,7 @@ static const size_t X300_RX_SW_BUFF_SIZE_ETH_MACOS  = 0x100000; //1Mib
 //where an element is 8 bytes. For best throughput ensure that the data frame fits in these buffers.
 //Also ensure that the kernel has enough frames to hold buffered TX and RX data
 static const size_t X300_PCIE_RX_DATA_FRAME_SIZE    = 8184;     //bytes
-//static const size_t X300_PCIE_TX_DATA_FRAME_SIZE    = 8192;     //bytes
-// This is a temporary solution: We're throttling PCIe MTU to avoid
-// underruns on Tx. Once we solve it on the FPGA side, need revert this commit.
-static const size_t X300_PCIE_TX_DATA_FRAME_SIZE    = 3000;     //bytes
+static const size_t X300_PCIE_TX_DATA_FRAME_SIZE    = 8184;     //bytes
 static const size_t X300_PCIE_DATA_NUM_FRAMES       = 2048;
 static const size_t X300_PCIE_MSG_FRAME_SIZE        = 256;      //bytes
 static const size_t X300_PCIE_MSG_NUM_FRAMES        = 64;
diff --git a/host/lib/usrp/x300/x300_radio_ctrl_impl.cpp b/host/lib/usrp/x300/x300_radio_ctrl_impl.cpp
index f4ad0d035..9bf61f998 100644
--- a/host/lib/usrp/x300/x300_radio_ctrl_impl.cpp
+++ b/host/lib/usrp/x300/x300_radio_ctrl_impl.cpp
@@ -126,8 +126,7 @@ UHD_RFNOC_RADIO_BLOCK_CONSTRUCTOR(x300_radio_ctrl)
         // Bind the daughterboard command time to the motherboard level property
         ////////////////////////////////////////////////////////////////
 
-        if (_tree->exists(fs_path("time") / "cmd") and
-                _tree->exists(fs_path("dboards" / _radio_slot /  "rx_frontends" / _rx_fe_map.at(i).db_fe_name / "time" / "cmd"))) {
+        if (_tree->exists(fs_path("time") / "cmd")) {
             _tree->access<time_spec_t>(fs_path("time") / "cmd")
                 .add_coerced_subscriber(boost::bind(&x300_radio_ctrl_impl::set_fe_cmd_time, this, _1, i));
         }
@@ -180,9 +179,11 @@ double x300_radio_ctrl_impl::set_rate(double rate)
 
 void x300_radio_ctrl_impl::set_fe_cmd_time(const time_spec_t &time, const size_t chan)
 {
-    _tree->access<time_spec_t>(
-            fs_path("dboards" / _radio_slot /  "rx_frontends" / _rx_fe_map.at(chan).db_fe_name / "time" / "cmd")
-    ).set(time);
+    if (_tree->exists(fs_path("dboards" / _radio_slot /  "rx_frontends" / _rx_fe_map.at(chan).db_fe_name / "time" / "cmd"))) {
+        _tree->access<time_spec_t>(
+                fs_path("dboards" / _radio_slot /  "rx_frontends" / _rx_fe_map.at(chan).db_fe_name / "time" / "cmd")
+        ).set(time);
+    }
 }
 
 void x300_radio_ctrl_impl::set_tx_antenna(const std::string &ant, const size_t chan)