Merge branch 'master' into ashish/register_api

4 files changed, 80 insertions, 58 deletions

diff --git a/host/lib/usrp/x300/x300_adc_dac_utils.cpp b/host/lib/usrp/x300/x300_adc_dac_utils.cpp
index b1483b3a5..e08825749 100644
--- a/host/lib/usrp/x300/x300_adc_dac_utils.cpp
+++ b/host/lib/usrp/x300/x300_adc_dac_utils.cpp
@@ -41,7 +41,7 @@ void x300_impl::synchronize_dacs(const std::vector<radio_perifs_t*>& radios)
     //Get a rough estimate of the cumulative command latency
     boost::posix_time::ptime t_start = boost::posix_time::microsec_clock::local_time();
     for (size_t i = 0; i < radios.size(); i++) {
-        radios[i]->ctrl->peek64(RB64_TIME_NOW); //Discard value. We are just timing the call
+        radios[i]->ctrl->peek64(uhd::usrp::radio::RB64_TIME_NOW); //Discard value. We are just timing the call
     }
     boost::posix_time::time_duration t_elapsed =
         boost::posix_time::microsec_clock::local_time() - t_start;
@@ -56,7 +56,7 @@ void x300_impl::synchronize_dacs(const std::vector<radio_perifs_t*>& radios)
     //Send the sync command
     for (size_t i = 0; i < radios.size(); i++) {
         radios[i]->ctrl->set_time(sync_time);
-        radios[i]->ctrl->poke32(TOREG(SR_DACSYNC), 0x1);    //Arm FRAMEP/N sync pulse
+        radios[i]->ctrl->poke32(uhd::usrp::radio::sr_addr(uhd::usrp::radio::DACSYNC), 0x1);    //Arm FRAMEP/N sync pulse
         radios[i]->ctrl->set_time(uhd::time_spec_t(0.0));   //Clear command time
     }
 
@@ -73,7 +73,7 @@ void x300_impl::synchronize_dacs(const std::vector<radio_perifs_t*>& radios)
 
 static void check_adc(uhd::wb_iface::sptr iface, const boost::uint32_t val, const boost::uint32_t i)
 {
-    boost::uint32_t adc_rb = iface->peek32(RB32_RX);
+    boost::uint32_t adc_rb = iface->peek32(uhd::usrp::radio::RB32_RX);
     adc_rb ^= 0xfffc0000; //adapt for I inversion in FPGA
     if (val != adc_rb) {
         throw uhd::runtime_error(
diff --git a/host/lib/usrp/x300/x300_image_loader.cpp b/host/lib/usrp/x300/x300_image_loader.cpp
index 321309868..9ec8a2e13 100644
--- a/host/lib/usrp/x300/x300_image_loader.cpp
+++ b/host/lib/usrp/x300/x300_image_loader.cpp
@@ -158,17 +158,31 @@ static void x300_validate_image(x300_session_t &session){
 static void x300_setup_session(x300_session_t &session,
                                const device_addr_t &args,
                                const std::string &filepath){
-    device_addr_t find_args;
-    find_args["type"] = "x300";
-    if(args.has_key("name")) find_args["name"] = args["name"];
-    if(args.has_key("serial")) find_args["serial"] = args["serial"];
-    if(args.has_key("ip-addr")) find_args["addr"] = args["ip-addr"];
-    else if(args.has_key("resource")) find_args["resource"] = args["resource"];
-
     device_addrs_t devs = x300_find(args);
-    session.found = (devs.size() > 0);
-    if(!session.found) return;
+    if(devs.size() == 0){
+        session.found = false;
+        return;
+    }
+    else if(devs.size() > 1){
+        std::string err_msg = "Could not resolve given args to a single X-Series device.\n"
+                              "Applicable devices:\n";
+
+        BOOST_FOREACH(const uhd::device_addr_t &dev, devs){
+            std::string identifier = dev.has_key("addr") ? "addr"
+                                                         : "resource";
+
+            err_msg += str(boost::format(" * %s (%s=%s)\n")
+                           % dev.get("product", "X3XX")
+                           % identifier
+                           % dev.get(identifier));
+        }
+
+        err_msg += "\nSpecify one of these devices with the given args to load an image onto it.";
+
+        throw uhd::runtime_error(err_msg);
+    }
 
+    session.found = true;
     session.dev_addr = devs[0];
     session.ethernet = session.dev_addr.has_key("addr");
     if(session.ethernet){
diff --git a/host/lib/usrp/x300/x300_impl.cpp b/host/lib/usrp/x300/x300_impl.cpp
index 437fec82d..229bf7b23 100644
--- a/host/lib/usrp/x300/x300_impl.cpp
+++ b/host/lib/usrp/x300/x300_impl.cpp
@@ -29,6 +29,7 @@
 #include <uhd/transport/if_addrs.hpp>
 #include <boost/foreach.hpp>
 #include <boost/bind.hpp>
+#include <boost/make_shared.hpp>
 #include <boost/functional/hash.hpp>
 #include <boost/assign/list_of.hpp>
 #include <fstream>
@@ -410,7 +411,7 @@ void x300_impl::setup_mb(const size_t mb_i, const uhd::device_addr_t &dev_addr)
 
         //Tell the quirks object which FIFOs carry TX stream data
         const boost::uint32_t tx_data_fifos[2] = {X300_RADIO_DEST_PREFIX_TX, X300_RADIO_DEST_PREFIX_TX + 3};
-        mb.rio_fpga_interface->get_kernel_proxy()->get_rio_quirks().register_tx_streams(tx_data_fifos);
+        mb.rio_fpga_interface->get_kernel_proxy()->get_rio_quirks().register_tx_streams(tx_data_fifos, 2);
 
         _tree->create<double>(mb_path / "link_max_rate").set(X300_MAX_RATE_PCIE);
     }
@@ -748,7 +749,7 @@ void x300_impl::setup_mb(const size_t mb_i, const uhd::device_addr_t &dev_addr)
     ////////////////////////////////////////////////////////////////////
     // front panel gpio
     ////////////////////////////////////////////////////////////////////
-    mb.fp_gpio = gpio_core_200::make(mb.radio_perifs[0].ctrl, TOREG(SR_FP_GPIO), RB32_FP_GPIO);
+    mb.fp_gpio = gpio_core_200::make(mb.radio_perifs[0].ctrl, radio::sr_addr(radio::GPIO), radio::RB32_FP_GPIO);
     BOOST_FOREACH(const gpio_attr_map_t::value_type attr, gpio_attr_map)
     {
         _tree->create<boost::uint32_t>(mb_path / "gpio" / "FP0" / attr.second)
@@ -943,30 +944,30 @@ void x300_impl::setup_radio(const size_t mb_i, const std::string &slot_name, con
     ////////////////////////////////////////////////////////////////
     // Setup peripherals
     ////////////////////////////////////////////////////////////////
-    perif.spi = spi_core_3000::make(perif.ctrl, TOREG(SR_SPI), RB32_SPI);
+    perif.spi = spi_core_3000::make(perif.ctrl, radio::sr_addr(radio::SPI), radio::RB32_SPI);
     perif.adc = x300_adc_ctrl::make(perif.spi, DB_ADC_SEN);
     perif.dac = x300_dac_ctrl::make(perif.spi, DB_DAC_SEN, mb.clock->get_master_clock_rate());
-    perif.leds = gpio_core_200_32wo::make(perif.ctrl, TOREG(SR_LEDS));
-    perif.rx_fe = rx_frontend_core_200::make(perif.ctrl, TOREG(SR_RX_FRONT));
+    perif.leds = gpio_core_200_32wo::make(perif.ctrl, radio::sr_addr(radio::LEDS));
+    perif.rx_fe = rx_frontend_core_200::make(perif.ctrl, radio::sr_addr(radio::RX_FRONT));
     perif.rx_fe->set_dc_offset(rx_frontend_core_200::DEFAULT_DC_OFFSET_VALUE);
     perif.rx_fe->set_dc_offset_auto(rx_frontend_core_200::DEFAULT_DC_OFFSET_ENABLE);
-    perif.tx_fe = tx_frontend_core_200::make(perif.ctrl, TOREG(SR_TX_FRONT));
+    perif.tx_fe = tx_frontend_core_200::make(perif.ctrl, radio::sr_addr(radio::TX_FRONT));
     perif.tx_fe->set_dc_offset(tx_frontend_core_200::DEFAULT_DC_OFFSET_VALUE);
     perif.tx_fe->set_iq_balance(tx_frontend_core_200::DEFAULT_IQ_BALANCE_VALUE);
-    perif.framer = rx_vita_core_3000::make(perif.ctrl, TOREG(SR_RX_CTRL));
-    perif.ddc = rx_dsp_core_3000::make(perif.ctrl, TOREG(SR_RX_DSP));
+    perif.framer = rx_vita_core_3000::make(perif.ctrl, radio::sr_addr(radio::RX_CTRL));
+    perif.ddc = rx_dsp_core_3000::make(perif.ctrl, radio::sr_addr(radio::RX_DSP));
     perif.ddc->set_link_rate(10e9/8); //whatever
-    perif.deframer = tx_vita_core_3000::make(perif.ctrl, TOREG(SR_TX_CTRL));
-    perif.duc = tx_dsp_core_3000::make(perif.ctrl, TOREG(SR_TX_DSP));
+    perif.deframer = tx_vita_core_3000::make(perif.ctrl, radio::sr_addr(radio::TX_CTRL));
+    perif.duc = tx_dsp_core_3000::make(perif.ctrl, radio::sr_addr(radio::TX_DSP));
     perif.duc->set_link_rate(10e9/8); //whatever
 
     ////////////////////////////////////////////////////////////////////
     // create time control objects
     ////////////////////////////////////////////////////////////////////
     time_core_3000::readback_bases_type time64_rb_bases;
-    time64_rb_bases.rb_now = RB64_TIME_NOW;
-    time64_rb_bases.rb_pps = RB64_TIME_PPS;
-    perif.time64 = time_core_3000::make(perif.ctrl, TOREG(SR_TIME), time64_rb_bases);
+    time64_rb_bases.rb_now = radio::RB64_TIME_NOW;
+    time64_rb_bases.rb_pps = radio::RB64_TIME_PPS;
+    perif.time64 = time_core_3000::make(perif.ctrl, radio::sr_addr(radio::TIME), time64_rb_bases);
 
     //Capture delays are calibrated every time. The status is only printed is the user
     //asks to run the xfer self cal using "self_cal_adc_delay"
@@ -1030,7 +1031,7 @@ void x300_impl::setup_radio(const size_t mb_i, const std::string &slot_name, con
 
     //create a new dboard interface
     x300_dboard_iface_config_t db_config;
-    db_config.gpio = gpio_core_200::make(perif.ctrl, TOREG(SR_GPIO), RB32_GPIO);
+    db_config.gpio = gpio_core_200::make(perif.ctrl, radio::sr_addr(radio::GPIO), radio::RB32_GPIO);
     db_config.spi = perif.spi;
     db_config.rx_spi_slaveno = DB_RX_SEN;
     db_config.tx_spi_slaveno = DB_TX_SEN;
@@ -1343,8 +1344,8 @@ void x300_impl::register_loopback_self_test(wb_iface::sptr iface)
     for (size_t i = 0; i < 100; i++)
     {
         boost::hash_combine(hash, i);
-        iface->poke32(TOREG(SR_TEST), boost::uint32_t(hash));
-        test_fail = iface->peek32(RB32_TEST) != boost::uint32_t(hash);
+        iface->poke32(radio::sr_addr(radio::TEST), boost::uint32_t(hash));
+        test_fail = iface->peek32(radio::RB32_TEST) != boost::uint32_t(hash);
         if (test_fail) break; //exit loop on any failure
     }
     UHD_MSG(status) << ((test_fail)? " fail" : "pass") << std::endl;
diff --git a/host/lib/usrp/x300/x300_regs.hpp b/host/lib/usrp/x300/x300_regs.hpp
index 350845f28..eba30abb5 100644
--- a/host/lib/usrp/x300/x300_regs.hpp
+++ b/host/lib/usrp/x300/x300_regs.hpp
@@ -18,40 +18,47 @@
 #ifndef INCLUDED_X300_REGS_HPP
 #define INCLUDED_X300_REGS_HPP
 
+#include <uhd/config.hpp>
 #include <stdint.h>
-#include <boost/cstdint.hpp>
 #include <uhd/utils/soft_register.hpp>
 
-#define TOREG(x) ((x)*4)
+namespace uhd { namespace usrp { namespace radio {
+
+static UHD_INLINE uint32_t sr_addr(const uint32_t offset)
+{
+    return offset * 4;
+}
+
+static const uint32_t DACSYNC    = 5;
+static const uint32_t LOOPBACK   = 6;
+static const uint32_t TEST       = 7;
+static const uint32_t SPI        = 8;
+static const uint32_t GPIO       = 16;
+static const uint32_t MISC_OUTS  = 24;
+static const uint32_t READBACK   = 32;
+static const uint32_t TX_CTRL    = 64;
+static const uint32_t RX_CTRL    = 96;
+static const uint32_t TIME       = 128;
+static const uint32_t RX_DSP     = 144;
+static const uint32_t TX_DSP     = 184;
+static const uint32_t LEDS       = 195;
+static const uint32_t FP_GPIO    = 200;
+static const uint32_t RX_FRONT   = 208;
+static const uint32_t TX_FRONT   = 216;
+
+static const uint32_t RB32_GPIO            = 0;
+static const uint32_t RB32_SPI             = 4;
+static const uint32_t RB64_TIME_NOW        = 8;
+static const uint32_t RB64_TIME_PPS        = 16;
+static const uint32_t RB32_TEST            = 24;
+static const uint32_t RB32_RX              = 28;
+static const uint32_t RB32_FP_GPIO         = 32;
+static const uint32_t RB32_MISC_INS        = 36;
+
+}}} // namespace
 
 #define localparam static const int
 
-localparam SR_DACSYNC    = 5;
-localparam SR_LOOPBACK   = 6;
-localparam SR_TEST       = 7;
-localparam SR_SPI        = 8;
-localparam SR_GPIO       = 16;
-localparam SR_MISC_OUTS  = 24;
-localparam SR_READBACK   = 32;
-localparam SR_TX_CTRL    = 64;
-localparam SR_RX_CTRL    = 96;
-localparam SR_TIME       = 128;
-localparam SR_RX_DSP     = 144;
-localparam SR_TX_DSP     = 184;
-localparam SR_LEDS       = 195;
-localparam SR_FP_GPIO    = 200;
-localparam SR_RX_FRONT   = 208;
-localparam SR_TX_FRONT   = 216;
-
-localparam RB32_GPIO     = 0;
-localparam RB32_SPI      = 4;
-localparam RB64_TIME_NOW = 8;
-localparam RB64_TIME_PPS = 16;
-localparam RB32_TEST     = 24;
-localparam RB32_RX       = 28;
-localparam RB32_FP_GPIO  = 32;
-localparam RB32_MISC_INS = 36;
-
 localparam BL_ADDRESS    = 0;
 localparam BL_DATA       = 1;
 
@@ -247,7 +254,7 @@ namespace uhd { namespace usrp { namespace x300 {
             UHD_DEFINE_SOFT_REG_FIELD(ADC_DATA_DLY_VAL,     /*width*/ 5, /*shift*/ 4);  //[8:4]
             UHD_DEFINE_SOFT_REG_FIELD(ADC_CHECKER_ENABLED,  /*width*/ 1, /*shift*/ 9);  //[9]
 
-            misc_outs_reg_t(): uhd::soft_reg32_wo_t(TOREG(SR_MISC_OUTS)) {
+            misc_outs_reg_t(): uhd::soft_reg32_wo_t(uhd::usrp::radio::sr_addr(uhd::usrp::radio::MISC_OUTS)) {
                 //Initial values
                 set(DAC_ENABLED, 0);
                 set(DAC_RESET_N, 0);
@@ -269,7 +276,7 @@ namespace uhd { namespace usrp { namespace x300 {
             UHD_DEFINE_SOFT_REG_FIELD(ADC_CHECKER1_Q_ERROR,  /*width*/ 1, /*shift*/ 6);  //[6]
             UHD_DEFINE_SOFT_REG_FIELD(ADC_CHECKER1_I_ERROR,  /*width*/ 1, /*shift*/ 7);  //[7]
 
-            misc_ins_reg_t(): uhd::soft_reg32_ro_t(RB32_MISC_INS) { }
+            misc_ins_reg_t(): uhd::soft_reg32_ro_t(uhd::usrp::radio::RB32_MISC_INS) { }
         } misc_ins_reg;
 
         radio_regmap_t(int radio_num) : soft_regmap_t("radio" + boost::lexical_cast<std::string>(radio_num) + "_regmap") {