Merge branch 'master' of ettus.sourcerepo.com:ettus/uhdpriv into usrp_e

8 files changed, 128 insertions, 32 deletions

diff --git a/host/lib/usrp/usrp2/clock_ctrl.cpp b/host/lib/usrp/usrp2/clock_ctrl.cpp
index d9baa66cf..b9be037c0 100644
--- a/host/lib/usrp/usrp2/clock_ctrl.cpp
+++ b/host/lib/usrp/usrp2/clock_ctrl.cpp
@@ -18,6 +18,7 @@
 #include "clock_ctrl.hpp"
 #include "ad9510_regs.hpp"
 #include "usrp2_regs.hpp" //spi slave constants
+#include <uhd/utils/assert.hpp>
 #include <boost/cstdint.hpp>
 
 using namespace uhd;
@@ -79,23 +80,63 @@ public:
         _ad9510_regs.power_down_lvds_cmos_out7 = enb? 0 : 1;
         _ad9510_regs.lvds_cmos_select_out7 = ad9510_regs_t::LVDS_CMOS_SELECT_OUT7_CMOS;
         _ad9510_regs.output_level_lvds_out7 = ad9510_regs_t::OUTPUT_LEVEL_LVDS_OUT7_1_75MA;
-        _ad9510_regs.bypass_divider_out7 = 1;
         this->write_reg(0x43);
+        this->update_regs();
+    }
+
+    void set_rate_rx_dboard_clock(double rate){
+        assert_has(get_rates_rx_dboard_clock(), rate, "rx dboard clock rate");
+        size_t divider = size_t(rate/get_master_clock_rate());
+        //bypass when the divider ratio is one
+        _ad9510_regs.bypass_divider_out7 = (divider == 1)? 1 : 0;
+        //calculate the low and high dividers
+        size_t high = divider/2;
+        size_t low = divider - high;
+        //set the registers (divider - 1)
+        _ad9510_regs.divider_low_cycles_out7 = low - 1;
+        _ad9510_regs.divider_high_cycles_out7 = high - 1;
+        //write the registers
+        this->write_reg(0x56);
         this->write_reg(0x57);
         this->update_regs();
     }
 
+    std::vector<double> get_rates_rx_dboard_clock(void){
+        std::vector<double> rates;
+        for (size_t i = 1; i <= 16+16; i++) rates.push_back(get_master_clock_rate()/i);
+        return rates;
+    }
+
     //uses output clock 6 (cmos)
     void enable_tx_dboard_clock(bool enb){
         _ad9510_regs.power_down_lvds_cmos_out6 = enb? 0 : 1;
         _ad9510_regs.lvds_cmos_select_out6 = ad9510_regs_t::LVDS_CMOS_SELECT_OUT6_CMOS;
         _ad9510_regs.output_level_lvds_out6 = ad9510_regs_t::OUTPUT_LEVEL_LVDS_OUT6_1_75MA;
-        _ad9510_regs.bypass_divider_out6 = 1;
         this->write_reg(0x42);
+        this->update_regs();
+    }
+
+    void set_rate_tx_dboard_clock(double rate){
+        assert_has(get_rates_tx_dboard_clock(), rate, "tx dboard clock rate");
+        size_t divider = size_t(rate/get_master_clock_rate());
+        //bypass when the divider ratio is one
+        _ad9510_regs.bypass_divider_out6 = (divider == 1)? 1 : 0;
+        //calculate the low and high dividers
+        size_t high = divider/2;
+        size_t low = divider - high;
+        //set the registers (divider - 1)
+        _ad9510_regs.divider_low_cycles_out6 = low - 1;
+        _ad9510_regs.divider_high_cycles_out6 = high - 1;
+        //write the registers
+        this->write_reg(0x54);
         this->write_reg(0x55);
         this->update_regs();
     }
 
+    std::vector<double> get_rates_tx_dboard_clock(void){
+        return get_rates_rx_dboard_clock(); //same master clock, same dividers...
+    }
+
     /*!
      * If we are to use an external reference, enable the charge pump.
      * \param enb true to enable the CP
diff --git a/host/lib/usrp/usrp2/clock_ctrl.hpp b/host/lib/usrp/usrp2/clock_ctrl.hpp
index 0ad8d9532..70a104a81 100644
--- a/host/lib/usrp/usrp2/clock_ctrl.hpp
+++ b/host/lib/usrp/usrp2/clock_ctrl.hpp
@@ -21,6 +21,7 @@
 #include "usrp2_iface.hpp"
 #include <boost/shared_ptr.hpp>
 #include <boost/utility.hpp>
+#include <vector>
 
 class usrp2_clock_ctrl : boost::noncopyable{
 public:
@@ -46,12 +47,38 @@ public:
     virtual void enable_rx_dboard_clock(bool enb) = 0;
 
     /*!
+     * Set the clock rate on the rx dboard clock.
+     * \param rate the new clock rate
+     * \throw exception when rate invalid
+     */
+    virtual void set_rate_rx_dboard_clock(double rate) = 0;
+
+    /*!
+     * Get a list of possible rx dboard clock rates.
+     * \return a list of clock rates in Hz
+     */
+    virtual std::vector<double> get_rates_rx_dboard_clock(void) = 0;
+
+    /*!
      * Enable/disable the tx dboard clock.
      * \param enb true to enable
      */
     virtual void enable_tx_dboard_clock(bool enb) = 0;
 
     /*!
+     * Set the clock rate on the tx dboard clock.
+     * \param rate the new clock rate
+     * \throw exception when rate invalid
+     */
+    virtual void set_rate_tx_dboard_clock(double rate) = 0;
+
+    /*!
+     * Get a list of possible tx dboard clock rates.
+     * \return a list of clock rates in Hz
+     */
+    virtual std::vector<double> get_rates_tx_dboard_clock(void) = 0;
+
+    /*!
      * Enable/disable external reference.
      * \param enb true to enable
      */
diff --git a/host/lib/usrp/usrp2/dboard_iface.cpp b/host/lib/usrp/usrp2/dboard_iface.cpp
index 114f83f41..6f2fb9396 100644
--- a/host/lib/usrp/usrp2/dboard_iface.cpp
+++ b/host/lib/usrp/usrp2/dboard_iface.cpp
@@ -21,6 +21,7 @@
 #include <uhd/usrp/dboard_iface.hpp>
 #include <uhd/types/dict.hpp>
 #include <uhd/utils/assert.hpp>
+#include <uhd/utils/algorithm.hpp>
 #include <boost/assign/list_of.hpp>
 #include <boost/asio.hpp> //htonl and ntohl
 #include <boost/math/special_functions/round.hpp>
@@ -36,8 +37,8 @@ public:
     usrp2_dboard_iface(usrp2_iface::sptr iface, usrp2_clock_ctrl::sptr clock_ctrl);
     ~usrp2_dboard_iface(void);
 
-    void write_aux_dac(unit_t, int, float);
-    float read_aux_adc(unit_t, int);
+    void write_aux_dac(unit_t, aux_dac_t, float);
+    float read_aux_adc(unit_t, aux_adc_t);
 
     void set_pin_ctrl(unit_t, boost::uint16_t);
     void set_atr_reg(unit_t, atr_reg_t, boost::uint16_t);
@@ -48,9 +49,10 @@ public:
     void write_i2c(boost::uint8_t, const byte_vector_t &);
     byte_vector_t read_i2c(boost::uint8_t, size_t);
 
+    void set_clock_rate(unit_t, double);
     double get_clock_rate(unit_t);
+    std::vector<double> get_clock_rates(unit_t);
     void set_clock_enabled(unit_t, bool);
-    bool get_clock_enabled(unit_t);
 
     void write_spi(
         unit_t unit,
@@ -73,6 +75,7 @@ private:
     boost::uint32_t _gpio_shadow;
 
     uhd::dict<unit_t, ad5623_regs_t> _dac_regs;
+    uhd::dict<unit_t, double> _clock_rates;
     void _write_aux_dac(unit_t);
 };
 
@@ -107,6 +110,10 @@ usrp2_dboard_iface::usrp2_dboard_iface(
         _dac_regs[unit].cmd  = ad5623_regs_t::CMD_RESET;
         this->_write_aux_dac(unit);
     }
+
+    //init the clock rate shadows with max rate clock
+    this->set_clock_rate(UNIT_RX, sorted(this->get_clock_rates(UNIT_RX)).back());
+    this->set_clock_rate(UNIT_TX, sorted(this->get_clock_rates(UNIT_TX)).back());
 }
 
 usrp2_dboard_iface::~usrp2_dboard_iface(void){
@@ -116,8 +123,24 @@ usrp2_dboard_iface::~usrp2_dboard_iface(void){
 /***********************************************************************
  * Clocks
  **********************************************************************/
-double usrp2_dboard_iface::get_clock_rate(unit_t){
-    return _clock_ctrl->get_master_clock_rate();
+void usrp2_dboard_iface::set_clock_rate(unit_t unit, double rate){
+    _clock_rates[unit] = rate; //set to shadow
+    switch(unit){
+    case UNIT_RX: _clock_ctrl->set_rate_rx_dboard_clock(rate); return;
+    case UNIT_TX: _clock_ctrl->set_rate_tx_dboard_clock(rate); return;
+    }
+}
+
+double usrp2_dboard_iface::get_clock_rate(unit_t unit){
+    return _clock_rates[unit]; //get from shadow
+}
+
+std::vector<double> usrp2_dboard_iface::get_clock_rates(unit_t unit){
+    switch(unit){
+    case UNIT_RX: return _clock_ctrl->get_rates_rx_dboard_clock();
+    case UNIT_TX: return _clock_ctrl->get_rates_tx_dboard_clock();
+    default: UHD_THROW_INVALID_CODE_PATH();
+    }
 }
 
 void usrp2_dboard_iface::set_clock_enabled(unit_t unit, bool enb){
@@ -240,31 +263,30 @@ void usrp2_dboard_iface::_write_aux_dac(unit_t unit){
     );
 }
 
-void usrp2_dboard_iface::write_aux_dac(unit_t unit, int which, float value){
+void usrp2_dboard_iface::write_aux_dac(unit_t unit, aux_dac_t which, float value){
     _dac_regs[unit].data = boost::math::iround(4095*value/3.3);
     _dac_regs[unit].cmd = ad5623_regs_t::CMD_WR_UP_DAC_CHAN_N;
-    //standardize on USRP1 interface, A=0, B=1, C=2, D=3
-    static const uhd::dict<
-        unit_t, uhd::dict<int, ad5623_regs_t::addr_t>
-    > unit_to_which_to_addr = map_list_of
+
+    typedef uhd::dict<aux_dac_t, ad5623_regs_t::addr_t> aux_dac_to_addr;
+    static const uhd::dict<unit_t, aux_dac_to_addr> unit_to_which_to_addr = map_list_of
         (UNIT_RX, map_list_of
-            (0, ad5623_regs_t::ADDR_DAC_B)
-            (1, ad5623_regs_t::ADDR_DAC_A)
-            (2, ad5623_regs_t::ADDR_DAC_A)
-            (3, ad5623_regs_t::ADDR_DAC_B)
+            (AUX_DAC_A, ad5623_regs_t::ADDR_DAC_B)
+            (AUX_DAC_B, ad5623_regs_t::ADDR_DAC_A)
+            (AUX_DAC_C, ad5623_regs_t::ADDR_DAC_A)
+            (AUX_DAC_D, ad5623_regs_t::ADDR_DAC_B)
         )
         (UNIT_TX, map_list_of
-            (0, ad5623_regs_t::ADDR_DAC_A)
-            (1, ad5623_regs_t::ADDR_DAC_B)
-            (2, ad5623_regs_t::ADDR_DAC_B)
-            (3, ad5623_regs_t::ADDR_DAC_A)
+            (AUX_DAC_A, ad5623_regs_t::ADDR_DAC_A)
+            (AUX_DAC_B, ad5623_regs_t::ADDR_DAC_B)
+            (AUX_DAC_C, ad5623_regs_t::ADDR_DAC_B)
+            (AUX_DAC_D, ad5623_regs_t::ADDR_DAC_A)
         )
     ;
     _dac_regs[unit].addr = unit_to_which_to_addr[unit][which];
     this->_write_aux_dac(unit);
 }
 
-float usrp2_dboard_iface::read_aux_adc(unit_t unit, int which){
+float usrp2_dboard_iface::read_aux_adc(unit_t unit, aux_adc_t which){
     static const uhd::dict<unit_t, int> unit_to_spi_adc = map_list_of
         (UNIT_RX, SPI_SS_RX_ADC)
         (UNIT_TX, SPI_SS_TX_ADC)
@@ -277,8 +299,10 @@ float usrp2_dboard_iface::read_aux_adc(unit_t unit, int which){
 
     //setup the spi registers
     ad7922_regs_t ad7922_regs;
-    ad7922_regs.mod = which; //normal mode: mod == chn
-    ad7922_regs.chn = which;
+    switch(which){
+    case AUX_ADC_A: ad7922_regs.mod = 0; break;
+    case AUX_ADC_B: ad7922_regs.mod = 1; break;
+    } ad7922_regs.chn = ad7922_regs.mod; //normal mode: mod == chn
 
     //write and read spi
     _iface->transact_spi(
diff --git a/host/lib/usrp/usrp2/fw_common.h b/host/lib/usrp/usrp2/fw_common.h
index 75f5b1779..242d268ec 100644
--- a/host/lib/usrp/usrp2/fw_common.h
+++ b/host/lib/usrp/usrp2/fw_common.h
@@ -32,9 +32,13 @@ extern "C" {
 #define _SINS_
 #endif
 
+// define limits on bytes per udp packet
+#define USRP2_MTU_BYTES 1500
+#define USRP2_UDP_BYTES ((USRP2_MTU_BYTES) - (2 + 14 + 20 + 8)) //size of headers (pad, eth, ip, udp)
+
 //defines the protocol version in this shared header
 //increment this value when the protocol is changed
-#define USRP2_PROTO_VERSION 3
+#define USRP2_PROTO_VERSION 4
 
 //used to differentiate control packets over data port
 #define USRP2_INVALID_VRT_HEADER 0
@@ -102,7 +106,7 @@ typedef struct{
         struct {
             _SINS_ uint8_t addr;
             _SINS_ uint8_t bytes;
-            _SINS_ uint8_t data[sizeof(_SINS_ uint32_t)];
+            _SINS_ uint8_t data[20];
         } i2c_args;
         struct {
             _SINS_ uint32_t addr;
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
index 6cb2a735b..aa0f63321 100644
--- a/host/lib/usrp/usrp2/io_impl.cpp
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -18,6 +18,7 @@
 #include "../../transport/vrt_packet_handler.hpp"
 #include "usrp2_impl.hpp"
 #include "usrp2_regs.hpp"
+#include <uhd/utils/thread_priority.hpp>
 #include <uhd/transport/convert_types.hpp>
 #include <uhd/transport/bounded_buffer.hpp>
 #include <boost/format.hpp>
@@ -78,6 +79,7 @@ managed_recv_buffer::sptr usrp2_impl::io_impl::get_recv_buff(void){
 }
 
 void usrp2_impl::io_impl::recv_pirate_loop(zero_copy_if::sptr zc_if){
+    set_thread_priority_safe();
     recv_pirate_running = true;
     while(recv_pirate_running){
         managed_recv_buffer::sptr buff = zc_if->get_recv_buff();
diff --git a/host/lib/usrp/usrp2/usrp2_iface.cpp b/host/lib/usrp/usrp2/usrp2_iface.cpp
index 6e0d3266a..83e98904e 100644
--- a/host/lib/usrp/usrp2/usrp2_iface.cpp
+++ b/host/lib/usrp/usrp2/usrp2_iface.cpp
@@ -146,7 +146,7 @@ public:
         _ctrl_transport->send(boost::asio::buffer(&out_copy, sizeof(usrp2_ctrl_data_t)));
 
         //loop until we get the packet or timeout
-        boost::uint8_t usrp2_ctrl_data_in_mem[1500]; //allocate MTU bytes for recv
+        boost::uint8_t usrp2_ctrl_data_in_mem[USRP2_UDP_BYTES]; //allocate max bytes for recv
         usrp2_ctrl_data_t *ctrl_data_in = reinterpret_cast<usrp2_ctrl_data_t *>(usrp2_ctrl_data_in_mem);
         while(true){
             size_t len = _ctrl_transport->recv(boost::asio::buffer(usrp2_ctrl_data_in_mem));
diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp
index 0837f4ac4..36c264c3c 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -79,12 +79,12 @@ uhd::device_addrs_t usrp2::find(const device_addr_t &hint){
     udp_transport->send(boost::asio::buffer(&ctrl_data_out, sizeof(ctrl_data_out)));
 
     //loop and recieve until the timeout
-    boost::uint8_t usrp2_ctrl_data_in_mem[1500]; //allocate MTU bytes for recv
+    boost::uint8_t usrp2_ctrl_data_in_mem[USRP2_UDP_BYTES]; //allocate max bytes for recv
     usrp2_ctrl_data_t *ctrl_data_in = reinterpret_cast<usrp2_ctrl_data_t *>(usrp2_ctrl_data_in_mem);
     while(true){
         size_t len = udp_transport->recv(asio::buffer(usrp2_ctrl_data_in_mem));
         //std::cout << len << "\n";
-        if (len >= sizeof(usrp2_ctrl_data_t)){
+        if (len > offsetof(usrp2_ctrl_data_t, data)){
             //handle the received data
             switch(ntohl(ctrl_data_in->id)){
             case USRP2_CTRL_ID_WAZZUP_DUDE:
diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp
index ccc09003e..2126b9565 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.hpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.hpp
@@ -141,15 +141,13 @@ private:
     /*******************************************************************
      * Deal with the rx and tx packet sizes
      ******************************************************************/
-    static const size_t _mtu = 1500; //FIXME we have no idea
-    static const size_t _hdrs = (2 + 14 + 20 + 8); //size of headers (pad, eth, ip, udp)
     static const size_t _max_rx_bytes_per_packet =
-        _mtu - _hdrs -
+        USRP2_UDP_BYTES -
         USRP2_HOST_RX_VRT_HEADER_WORDS32*sizeof(boost::uint32_t) -
         USRP2_HOST_RX_VRT_TRAILER_WORDS32*sizeof(boost::uint32_t)
     ;
     static const size_t _max_tx_bytes_per_packet =
-        _mtu - _hdrs -
+        USRP2_UDP_BYTES -
         uhd::transport::vrt::max_header_words32*sizeof(boost::uint32_t)
     ;