1 files changed, 97 insertions, 87 deletions

diff --git a/host/lib/usrp/usrp2/dboard_interface.cpp b/host/lib/usrp/usrp2/dboard_interface.cpp
index 6dd756420..8a3df08cb 100644
--- a/host/lib/usrp/usrp2/dboard_interface.cpp
+++ b/host/lib/usrp/usrp2/dboard_interface.cpp
@@ -17,6 +17,7 @@
 
 #include "usrp2_impl.hpp"
 #include "usrp2_regs.hpp"
+#include "ad9510_regs.hpp"
 #include <uhd/types/dict.hpp>
 #include <uhd/utils/assert.hpp>
 #include <boost/assign/list_of.hpp>
@@ -29,26 +30,39 @@ public:
     usrp2_dboard_interface(usrp2_impl *impl);
     ~usrp2_dboard_interface(void);
 
-    void write_aux_dac(unit_type_t, int, int);
-    int read_aux_adc(unit_type_t, int);
+    void write_aux_dac(unit_t, int, int);
+    int read_aux_adc(unit_t, int);
 
-    void set_atr_reg(gpio_bank_t, atr_reg_t, boost::uint16_t);
-    void set_gpio_ddr(gpio_bank_t, boost::uint16_t);
-    boost::uint16_t read_gpio(gpio_bank_t);
+    void set_atr_reg(unit_t, atr_reg_t, boost::uint16_t);
+    void set_gpio_ddr(unit_t, boost::uint16_t);
+    boost::uint16_t read_gpio(unit_t);
 
     void write_i2c(int, const byte_vector_t &);
     byte_vector_t read_i2c(int, size_t);
 
-    double get_rx_clock_rate(void);
-    double get_tx_clock_rate(void);
+    double get_clock_rate(unit_t);
+    void set_clock_enabled(unit_t, bool);
+    bool get_clock_enabled(unit_t);
 
-private:
-    byte_vector_t transact_spi(
-        spi_dev_t, spi_edge_t, const byte_vector_t &, bool
+    void write_spi(
+        unit_t unit,
+        const spi_config_t &config,
+        boost::uint32_t data,
+        size_t num_bits
+    );
+
+    boost::uint32_t read_write_spi(
+        unit_t unit,
+        const spi_config_t &config,
+        boost::uint32_t data,
+        size_t num_bits
     );
 
+private:
     usrp2_impl *_impl;
     boost::uint32_t _ddr_shadow;
+    ad9510_regs_t _ad9510_regs;
+    uhd::dict<unit_t, bool> _clock_enb_shadow;
 };
 
 /***********************************************************************
@@ -79,119 +93,115 @@ usrp2_dboard_interface::~usrp2_dboard_interface(void){
 }
 
 /***********************************************************************
- * Clock Rates
+ * Clocks
  **********************************************************************/
-double usrp2_dboard_interface::get_rx_clock_rate(void){
+double usrp2_dboard_interface::get_clock_rate(unit_t){
     return _impl->get_master_clock_freq();
 }
 
-double usrp2_dboard_interface::get_tx_clock_rate(void){
-    return _impl->get_master_clock_freq();
+void usrp2_dboard_interface::set_clock_enabled(unit_t unit, bool enb){
+    uint16_t data = 0;
+    switch(unit){
+    case UNIT_RX:
+        _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;
+        data = _ad9510_regs.get_write_reg(0x43);
+        break;
+    case UNIT_TX:
+        _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;
+        data = _ad9510_regs.get_write_reg(0x42);
+        break;
+    }
+    _impl->transact_spi(SPI_SS_AD9510, spi_config_t::EDGE_RISE, data, 24, false /*no rb*/);
+
+    _ad9510_regs.update_registers = 1;
+    _impl->transact_spi(SPI_SS_AD9510, spi_config_t::EDGE_RISE, _ad9510_regs.get_write_reg(0x5a), 24, false /*no rb*/);
+    _clock_enb_shadow[unit] = unit;
+}
+
+bool usrp2_dboard_interface::get_clock_enabled(unit_t unit){
+    return _clock_enb_shadow[unit];
 }
 
 /***********************************************************************
  * GPIO
  **********************************************************************/
-static int bank_to_shift(dboard_interface::gpio_bank_t bank){
-    switch(bank){
-    case dboard_interface::GPIO_BANK_RX: return 0;
-    case dboard_interface::GPIO_BANK_TX: return 16;
+static int unit_to_shift(dboard_interface::unit_t unit){
+    switch(unit){
+    case dboard_interface::UNIT_RX: return 0;
+    case dboard_interface::UNIT_TX: return 16;
     }
-    throw std::runtime_error("unknown gpio bank type");
+    throw std::runtime_error("unknown unit type");
 }
 
-void usrp2_dboard_interface::set_gpio_ddr(gpio_bank_t bank, boost::uint16_t value){
+void usrp2_dboard_interface::set_gpio_ddr(unit_t unit, boost::uint16_t value){
     _ddr_shadow = \
-        (_ddr_shadow & ~(0xffff << bank_to_shift(bank))) |
-        (boost::uint32_t(value) << bank_to_shift(bank));
+        (_ddr_shadow & ~(0xffff << unit_to_shift(unit))) |
+        (boost::uint32_t(value) << unit_to_shift(unit));
     _impl->poke32(FR_GPIO_DDR, _ddr_shadow);
 }
 
-boost::uint16_t usrp2_dboard_interface::read_gpio(gpio_bank_t bank){
-    return boost::uint16_t(_impl->peek32(FR_GPIO_IO) >> bank_to_shift(bank));
+boost::uint16_t usrp2_dboard_interface::read_gpio(unit_t unit){
+    return boost::uint16_t(_impl->peek32(FR_GPIO_IO) >> unit_to_shift(unit));
 }
 
-void usrp2_dboard_interface::set_atr_reg(gpio_bank_t bank, atr_reg_t atr, boost::uint16_t value){
-    //define mapping of bank to atr regs to register address
+void usrp2_dboard_interface::set_atr_reg(unit_t unit, atr_reg_t atr, boost::uint16_t value){
+    //define mapping of unit to atr regs to register address
     static const uhd::dict<
-        gpio_bank_t, uhd::dict<atr_reg_t, boost::uint32_t>
-    > bank_to_atr_to_addr = boost::assign::map_list_of
-        (GPIO_BANK_RX, boost::assign::map_list_of
+        unit_t, uhd::dict<atr_reg_t, boost::uint32_t>
+    > unit_to_atr_to_addr = boost::assign::map_list_of
+        (UNIT_RX, boost::assign::map_list_of
             (ATR_REG_IDLE,        FR_ATR_IDLE_RXSIDE)
             (ATR_REG_TX_ONLY,     FR_ATR_INTX_RXSIDE)
             (ATR_REG_RX_ONLY,     FR_ATR_INRX_RXSIDE)
             (ATR_REG_FULL_DUPLEX, FR_ATR_FULL_RXSIDE)
         )
-        (GPIO_BANK_TX, boost::assign::map_list_of
+        (UNIT_TX, boost::assign::map_list_of
             (ATR_REG_IDLE,        FR_ATR_IDLE_TXSIDE)
             (ATR_REG_TX_ONLY,     FR_ATR_INTX_TXSIDE)
             (ATR_REG_RX_ONLY,     FR_ATR_INRX_TXSIDE)
             (ATR_REG_FULL_DUPLEX, FR_ATR_FULL_TXSIDE)
         )
     ;
-    _impl->poke16(bank_to_atr_to_addr[bank][atr], value);
+    _impl->poke16(unit_to_atr_to_addr[unit][atr], value);
 }
 
 /***********************************************************************
  * SPI
  **********************************************************************/
 /*!
- * Static function to convert a spi dev enum
- * to an over-the-wire value for the usrp2 control.
- * \param dev the dboard interface spi dev enum
+ * Static function to convert a unit type enum
+ * to an over-the-wire value for the spi device.
+ * \param unit the dboard interface unit type enum
  * \return an over the wire representation
  */
-static boost::uint8_t spi_dev_to_otw(dboard_interface::spi_dev_t dev){
-    switch(dev){
-    case uhd::usrp::dboard_interface::SPI_DEV_TX: return SPI_SS_TX_DB;
-    case uhd::usrp::dboard_interface::SPI_DEV_RX: return SPI_SS_RX_DB;
+static boost::uint8_t unit_to_otw_spi_dev(dboard_interface::unit_t unit){
+    switch(unit){
+    case dboard_interface::UNIT_TX: return SPI_SS_TX_DB;
+    case dboard_interface::UNIT_RX: return SPI_SS_RX_DB;
     }
-    throw std::invalid_argument("unknown spi device type");
+    throw std::invalid_argument("unknown unit type");
 }
 
-/*!
- * Static function to convert a spi edge enum
- * to an over-the-wire value for the usrp2 control.
- * \param edge the dboard interface spi edge enum
- * \return an over the wire representation
- */
-static boost::uint8_t spi_edge_to_otw(dboard_interface::spi_edge_t edge){
-    switch(edge){
-    case uhd::usrp::dboard_interface::SPI_EDGE_RISE: return USRP2_CLK_EDGE_RISE;
-    case uhd::usrp::dboard_interface::SPI_EDGE_FALL: return USRP2_CLK_EDGE_FALL;
-    }
-    throw std::invalid_argument("unknown spi edge type");
+void usrp2_dboard_interface::write_spi(
+    unit_t unit,
+    const spi_config_t &config,
+    boost::uint32_t data,
+    size_t num_bits
+){
+    _impl->transact_spi(unit_to_otw_spi_dev(unit), config, data, num_bits, false /*no rb*/);
 }
 
-dboard_interface::byte_vector_t usrp2_dboard_interface::transact_spi(
-    spi_dev_t dev,
-    spi_edge_t edge,
-    const byte_vector_t &buf,
-    bool readback
+boost::uint32_t usrp2_dboard_interface::read_write_spi(
+    unit_t unit,
+    const spi_config_t &config,
+    boost::uint32_t data,
+    size_t num_bits
 ){
-    //setup the out data
-    usrp2_ctrl_data_t out_data;
-    out_data.id = htonl(USRP2_CTRL_ID_TRANSACT_ME_SOME_SPI_BRO);
-    out_data.data.spi_args.dev = spi_dev_to_otw(dev);
-    out_data.data.spi_args.edge = spi_edge_to_otw(edge);
-    out_data.data.spi_args.readback = (readback)? 1 : 0;
-    out_data.data.spi_args.bytes = buf.size();
-
-    //limitation of spi transaction size
-    ASSERT_THROW(buf.size() <= sizeof(out_data.data.spi_args.data));
-
-    //copy in the data
-    std::copy(buf.begin(), buf.end(), out_data.data.spi_args.data);
-
-    //send and recv
-    usrp2_ctrl_data_t in_data = _impl->ctrl_send_and_recv(out_data);
-    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_OMG_TRANSACTED_SPI_DUDE);
-    ASSERT_THROW(in_data.data.spi_args.bytes == buf.size());
-
-    //copy out the data
-    byte_vector_t result(buf.size());
-    std::copy(in_data.data.spi_args.data, in_data.data.spi_args.data + buf.size(), result.begin());
-    return result;
+    return _impl->transact_spi(unit_to_otw_spi_dev(unit), config, data, num_bits, true /*rb*/);
 }
 
 /***********************************************************************
@@ -245,19 +255,19 @@ dboard_interface::byte_vector_t usrp2_dboard_interface::read_i2c(int i2c_addr, s
  * \param unit the dboard interface unit type enum
  * \return an over the wire representation
  */
-static boost::uint8_t spi_dev_to_otw(dboard_interface::unit_type_t unit){
+static boost::uint8_t unit_to_otw(dboard_interface::unit_t unit){
     switch(unit){
-    case uhd::usrp::dboard_interface::UNIT_TYPE_TX: return USRP2_DIR_TX;
-    case uhd::usrp::dboard_interface::UNIT_TYPE_RX: return USRP2_DIR_RX;
+    case dboard_interface::UNIT_TX: return USRP2_DIR_TX;
+    case dboard_interface::UNIT_RX: return USRP2_DIR_RX;
     }
-    throw std::invalid_argument("unknown unit type type");
+    throw std::invalid_argument("unknown unit type");
 }
 
-void usrp2_dboard_interface::write_aux_dac(dboard_interface::unit_type_t unit, int which, int value){
+void usrp2_dboard_interface::write_aux_dac(unit_t unit, int which, int value){
     //setup the out data
     usrp2_ctrl_data_t out_data;
     out_data.id = htonl(USRP2_CTRL_ID_WRITE_THIS_TO_THE_AUX_DAC_BRO);
-    out_data.data.aux_args.dir = spi_dev_to_otw(unit);
+    out_data.data.aux_args.dir = unit_to_otw(unit);
     out_data.data.aux_args.which = which;
     out_data.data.aux_args.value = htonl(value);
 
@@ -266,11 +276,11 @@ void usrp2_dboard_interface::write_aux_dac(dboard_interface::unit_type_t unit, i
     ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_DONE_WITH_THAT_AUX_DAC_DUDE);
 }
 
-int usrp2_dboard_interface::read_aux_adc(dboard_interface::unit_type_t unit, int which){
+int usrp2_dboard_interface::read_aux_adc(unit_t unit, int which){
     //setup the out data
     usrp2_ctrl_data_t out_data;
     out_data.id = htonl(USRP2_CTRL_ID_READ_FROM_THIS_AUX_ADC_BRO);
-    out_data.data.aux_args.dir = spi_dev_to_otw(unit);
+    out_data.data.aux_args.dir = unit_to_otw(unit);
     out_data.data.aux_args.which = which;
 
     //send and recv