Merge branch 'master' into next

Conflicts:
	fpga/usrp2/top/u2plus/Makefile.N200

7 files changed, 97 insertions, 52 deletions

diff --git a/host/lib/usrp/usrp2/CMakeLists.txt b/host/lib/usrp/usrp2/CMakeLists.txt
index e8811a8fb..49be9ac7d 100644
--- a/host/lib/usrp/usrp2/CMakeLists.txt
+++ b/host/lib/usrp/usrp2/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright 2010 Ettus Research LLC
+# Copyright 2010-2011 Ettus Research LLC
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
diff --git a/host/lib/usrp/usrp2/clock_ctrl.cpp b/host/lib/usrp/usrp2/clock_ctrl.cpp
index abda53bf2..7572ed6b1 100644
--- a/host/lib/usrp/usrp2/clock_ctrl.cpp
+++ b/host/lib/usrp/usrp2/clock_ctrl.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010 Ettus Research LLC
+// Copyright 2010-2011 Ettus Research LLC
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
index 340e9d155..07cbd2432 100644
--- a/host/lib/usrp/usrp2/io_impl.cpp
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -25,7 +25,8 @@
 #include <uhd/transport/bounded_buffer.hpp>
 #include <boost/format.hpp>
 #include <boost/bind.hpp>
-#include <boost/thread.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/barrier.hpp>
 #include <iostream>
 
 using namespace uhd;
@@ -209,11 +210,10 @@ struct usrp2_impl::io_impl{
     vrt_packet_handler::send_state packet_handler_send_state;
 
     //methods and variables for the pirate crew
-    void recv_pirate_loop(usrp2_mboard_impl::sptr, zero_copy_if::sptr, size_t);
+    void recv_pirate_loop(boost::barrier &, usrp2_mboard_impl::sptr, zero_copy_if::sptr, size_t);
     boost::thread_group recv_pirate_crew;
     bool recv_pirate_crew_raiding;
     bounded_buffer<async_metadata_t> async_msg_fifo;
-    boost::mutex spawn_mutex;
 };
 
 /***********************************************************************
@@ -223,13 +223,15 @@ struct usrp2_impl::io_impl{
  * - put async message packets into queue
  **********************************************************************/
 void usrp2_impl::io_impl::recv_pirate_loop(
-    usrp2_mboard_impl::sptr mboard, zero_copy_if::sptr err_xport, size_t index
+    boost::barrier &spawn_barrier,
+    usrp2_mboard_impl::sptr mboard,
+    zero_copy_if::sptr err_xport,
+    size_t index
 ){
+    spawn_barrier.wait();
     set_thread_priority_safe();
     recv_pirate_crew_raiding = true;
 
-    spawn_mutex.unlock();
-
     //store a reference to the flow control monitor (offset by max dsps)
     flow_control_monitor &fc_mon = *(this->fc_mons[index*usrp2_mboard_impl::MAX_NUM_DSPS]);
 
@@ -286,19 +288,16 @@ void usrp2_impl::io_init(void){
     _io_impl = UHD_PIMPL_MAKE(io_impl, (dsp_xports));
 
     //create a new pirate thread for each zc if (yarr!!)
+    boost::barrier spawn_barrier(_mboards.size()+1);
     for (size_t i = 0; i < _mboards.size(); i++){
-        //lock the unlocked mutex (non-blocking)
-        _io_impl->spawn_mutex.lock();
         //spawn a new pirate to plunder the recv booty
         _io_impl->recv_pirate_crew.create_thread(boost::bind(
             &usrp2_impl::io_impl::recv_pirate_loop,
-            _io_impl.get(), _mboards.at(i), err_xports.at(i), i
+            _io_impl.get(), boost::ref(spawn_barrier),
+            _mboards.at(i), err_xports.at(i), i
         ));
-        //block here until the spawned thread unlocks
-        _io_impl->spawn_mutex.lock();
-        //exit loop iteration in an unlocked condition
-        _io_impl->spawn_mutex.unlock();
     }
+    spawn_barrier.wait();
 
     //update mapping here since it didnt b4 when io init not called first
     update_xport_channel_mapping();
diff --git a/host/lib/usrp/usrp2/mboard_impl.cpp b/host/lib/usrp/usrp2/mboard_impl.cpp
index 40fc5098b..29e0535f8 100644
--- a/host/lib/usrp/usrp2/mboard_impl.cpp
+++ b/host/lib/usrp/usrp2/mboard_impl.cpp
@@ -66,6 +66,18 @@ usrp2_mboard_impl::usrp2_mboard_impl(
         device_addr["addr"], BOOST_STRINGIZE(USRP2_UDP_CTRL_PORT)
     )))
 {
+
+    //check the fpga compatibility number
+    const boost::uint32_t fpga_compat_num = _iface->peek32(_iface->regs.compat_num_rb);
+    if (fpga_compat_num != USRP2_FPGA_COMPAT_NUM){
+        throw uhd::runtime_error(str(boost::format(
+            "\nPlease update the firmware and FPGA images for your device.\n"
+            "See the application notes for USRP2/N-Series for instructions.\n"
+            "Expected FPGA compatibility number %d, but got %d:\n"
+            "The FPGA build is not compatible with the host code build."
+        ) % int(USRP2_FPGA_COMPAT_NUM) % fpga_compat_num));
+    }
+
     //construct transports for dsp and async errors
     std::cout << "Making transport for DSP0..." << std::endl;
     device.dsp_xports.push_back(udp_zero_copy::make(
diff --git a/host/lib/usrp/usrp2/usrp2_iface.cpp b/host/lib/usrp/usrp2/usrp2_iface.cpp
index e3827233b..d88d31765 100644
--- a/host/lib/usrp/usrp2/usrp2_iface.cpp
+++ b/host/lib/usrp/usrp2/usrp2_iface.cpp
@@ -34,14 +34,32 @@ using namespace uhd::transport;
 
 static const double CTRL_RECV_TIMEOUT = 1.0;
 
+static const boost::uint32_t MIN_PROTO_COMPAT_SPI = 7;
+static const boost::uint32_t MIN_PROTO_COMPAT_I2C = 7;
+// The register compat number must reflect the protocol compatibility
+// and the compatibility of the register mapping (more likely to change).
+static const boost::uint32_t MIN_PROTO_COMPAT_REG = USRP2_FW_COMPAT_NUM;
+static const boost::uint32_t MIN_PROTO_COMPAT_UART = 7;
+
 class usrp2_iface_impl : public usrp2_iface{
 public:
 /***********************************************************************
  * Structors
  **********************************************************************/
-    usrp2_iface_impl(udp_simple::sptr ctrl_transport){
-        _ctrl_transport = ctrl_transport;
-        _ctrl_seq_num = 0;
+    usrp2_iface_impl(udp_simple::sptr ctrl_transport):
+        _ctrl_transport(ctrl_transport),
+        _ctrl_seq_num(0),
+        _protocol_compat(0) //initialized below...
+    {
+        //Obtain the firmware's compat number.
+        //Save the response compat number for communication.
+        //TODO can choose to reject certain older compat numbers
+        usrp2_ctrl_data_t ctrl_data;
+        ctrl_data.id = htonl(USRP2_CTRL_ID_WAZZUP_BRO);
+        ctrl_data = ctrl_send_and_recv(ctrl_data, 0, ~0);
+        if (ntohl(ctrl_data.id) != USRP2_CTRL_ID_WAZZUP_DUDE)
+            throw uhd::runtime_error("firmware not responding");
+        _protocol_compat = ntohl(ctrl_data.proto_ver);
 
         mb_eeprom = mboard_eeprom_t(*this, mboard_eeprom_t::MAP_N100);
         switch(this->get_rev()){
@@ -59,15 +77,6 @@ public:
             regs = usrp2_get_regs(false);
             break;
         }
-
-        //check the fpga compatibility number
-        const boost::uint32_t fpga_compat_num = this->peek32(this->regs.compat_num_rb);
-        if (fpga_compat_num != USRP2_FPGA_COMPAT_NUM){
-            throw uhd::runtime_error(str(boost::format(
-                "Expected fpga compatibility number %d, but got %d:\n"
-                "The fpga build is not compatible with the host code build."
-            ) % int(USRP2_FPGA_COMPAT_NUM) % fpga_compat_num));
-        }
     }
 
 /***********************************************************************
@@ -115,7 +124,7 @@ public:
         out_data.data.spi_args.data = htonl(data);
 
         //send and recv
-        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data);
+        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data, MIN_PROTO_COMPAT_SPI);
         UHD_ASSERT_THROW(ntohl(in_data.id) == USRP2_CTRL_ID_OMG_TRANSACTED_SPI_DUDE);
 
         return ntohl(in_data.data.spi_args.data);
@@ -138,7 +147,7 @@ public:
         std::copy(buf.begin(), buf.end(), out_data.data.i2c_args.data);
 
         //send and recv
-        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data);
+        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data, MIN_PROTO_COMPAT_I2C);
         UHD_ASSERT_THROW(ntohl(in_data.id) == USRP2_CTRL_ID_COOL_IM_DONE_I2C_WRITE_DUDE);
     }
 
@@ -153,7 +162,7 @@ public:
         UHD_ASSERT_THROW(num_bytes <= sizeof(out_data.data.i2c_args.data));
 
         //send and recv
-        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data);
+        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data, MIN_PROTO_COMPAT_I2C);
         UHD_ASSERT_THROW(ntohl(in_data.id) == USRP2_CTRL_ID_HERES_THE_I2C_DATA_DUDE);
         UHD_ASSERT_THROW(in_data.data.i2c_args.addr = num_bytes);
 
@@ -186,7 +195,7 @@ public:
         std::copy(item.begin(), item.end(), out_data.data.uart_args.data);
 
         //send and recv
-        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data);
+        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data, MIN_PROTO_COMPAT_UART);
         UHD_ASSERT_THROW(ntohl(in_data.id) == USRP2_CTRL_ID_MAN_I_TOTALLY_WROTE_THAT_UART_DUDE);
       }
     }
@@ -205,7 +214,7 @@ public:
         //UHD_ASSERT_THROW(num_bytes <= sizeof(out_data.data.uart_args.data));
 
         //send and recv
-        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data);
+        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data, MIN_PROTO_COMPAT_UART);
         UHD_ASSERT_THROW(ntohl(in_data.id) == USRP2_CTRL_ID_I_HELLA_READ_THAT_UART_DUDE);
         readlen = in_data.data.uart_args.bytes;
 
@@ -226,12 +235,16 @@ public:
 /***********************************************************************
  * Send/Recv over control
  **********************************************************************/
-    usrp2_ctrl_data_t ctrl_send_and_recv(const usrp2_ctrl_data_t &out_data){
+    usrp2_ctrl_data_t ctrl_send_and_recv(
+        const usrp2_ctrl_data_t &out_data,
+        boost::uint32_t lo = USRP2_FW_COMPAT_NUM,
+        boost::uint32_t hi = USRP2_FW_COMPAT_NUM
+    ){
         boost::mutex::scoped_lock lock(_ctrl_mutex);
 
         //fill in the seq number and send
         usrp2_ctrl_data_t out_copy = out_data;
-        out_copy.proto_ver = htonl(USRP2_FW_COMPAT_NUM);
+        out_copy.proto_ver = htonl(_protocol_compat);
         out_copy.seq = htonl(++_ctrl_seq_num);
         _ctrl_transport->send(boost::asio::buffer(&out_copy, sizeof(usrp2_ctrl_data_t)));
 
@@ -240,11 +253,14 @@ public:
         const usrp2_ctrl_data_t *ctrl_data_in = reinterpret_cast<const 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), CTRL_RECV_TIMEOUT);
-            if(len >= sizeof(boost::uint32_t) and ntohl(ctrl_data_in->proto_ver) != USRP2_FW_COMPAT_NUM){
+            boost::uint32_t compat = ntohl(ctrl_data_in->proto_ver);
+            if(len >= sizeof(boost::uint32_t) and (hi < compat or lo > compat)){
                 throw uhd::runtime_error(str(boost::format(
-                    "Expected protocol compatibility number %d, but got %d:\n"
+                    "\nPlease update the firmware and FPGA images for your device.\n"
+                    "See the application notes for USRP2/N-Series for instructions.\n"
+                    "Expected protocol compatibility number %s, but got %d:\n"
                     "The firmware build is not compatible with the host code build."
-                ) % int(USRP2_FW_COMPAT_NUM) % ntohl(ctrl_data_in->proto_ver)));
+                ) % ((lo == hi)? (boost::format("%d") % hi) : (boost::format("[%d to %d]") % lo % hi)) % compat));
             }
             if (len >= sizeof(usrp2_ctrl_data_t) and ntohl(ctrl_data_in->seq) == _ctrl_seq_num){
                 return *ctrl_data_in;
@@ -284,6 +300,7 @@ private:
     //used in send/recv
     boost::mutex _ctrl_mutex;
     boost::uint32_t _ctrl_seq_num;
+    boost::uint32_t _protocol_compat;
 
 /***********************************************************************
  * Private Templated Peek and Poke
@@ -297,7 +314,7 @@ private:
         out_data.data.poke_args.num_bytes = sizeof(T);
 
         //send and recv
-        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data);
+        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data, MIN_PROTO_COMPAT_REG);
         UHD_ASSERT_THROW(ntohl(in_data.id) == USRP2_CTRL_ID_OMG_POKED_REGISTER_SO_BAD_DUDE);
     }
 
@@ -309,7 +326,7 @@ private:
         out_data.data.poke_args.num_bytes = sizeof(T);
 
         //send and recv
-        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data);
+        usrp2_ctrl_data_t in_data = this->ctrl_send_and_recv(out_data, MIN_PROTO_COMPAT_REG);
         UHD_ASSERT_THROW(ntohl(in_data.id) == USRP2_CTRL_ID_WOAH_I_DEFINITELY_PEEKED_IT_DUDE);
         return T(ntohl(in_data.data.poke_args.data));
     }
diff --git a/host/lib/usrp/usrp2/usrp2_iface.hpp b/host/lib/usrp/usrp2/usrp2_iface.hpp
index df53ec66a..08f3955f1 100644
--- a/host/lib/usrp/usrp2/usrp2_iface.hpp
+++ b/host/lib/usrp/usrp2/usrp2_iface.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010 Ettus Research LLC
+// Copyright 2010-2011 Ettus Research LLC
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp
index 96552929a..cb92b1921 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -171,6 +171,15 @@ static mtu_result_t determine_mtu(const std::string &addr){
     usrp2_ctrl_data_t *ctrl_data = reinterpret_cast<usrp2_ctrl_data_t *>(buffer);
     static const double echo_timeout = 0.020; //20 ms
 
+    //test holler - check if its supported in this fw version
+    ctrl_data->id = htonl(USRP2_CTRL_ID_HOLLER_AT_ME_BRO);
+    ctrl_data->proto_ver = htonl(USRP2_FW_COMPAT_NUM);
+    ctrl_data->data.echo_args.len = htonl(sizeof(usrp2_ctrl_data_t));
+    udp_sock->send(boost::asio::buffer(buffer, sizeof(usrp2_ctrl_data_t)));
+    udp_sock->recv(boost::asio::buffer(buffer), echo_timeout);
+    if (ntohl(ctrl_data->id) != USRP2_CTRL_ID_HOLLER_BACK_DUDE)
+        throw uhd::not_implemented_error("holler protocol not implemented");
+
     size_t min_recv_mtu = sizeof(usrp2_ctrl_data_t), max_recv_mtu = sizeof(buffer);
     size_t min_send_mtu = sizeof(usrp2_ctrl_data_t), max_send_mtu = sizeof(buffer);
 
@@ -233,23 +242,31 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr){
 
     device_addrs_t device_args = separate_device_addr(device_addr);
 
-    //calculate the minimum send and recv mtu of all devices
-    mtu_result_t mtu = determine_mtu(device_args[0]["addr"]);
-    for (size_t i = 1; i < device_args.size(); i++){
-        mtu_result_t mtu_i = determine_mtu(device_args[i]["addr"]);
-        mtu.recv_mtu = std::min(mtu.recv_mtu, mtu_i.recv_mtu);
-        mtu.send_mtu = std::min(mtu.send_mtu, mtu_i.send_mtu);
-    }
+    try{
+        //calculate the minimum send and recv mtu of all devices
+        mtu_result_t mtu = determine_mtu(device_args[0]["addr"]);
+        for (size_t i = 1; i < device_args.size(); i++){
+            mtu_result_t mtu_i = determine_mtu(device_args[i]["addr"]);
+            mtu.recv_mtu = std::min(mtu.recv_mtu, mtu_i.recv_mtu);
+            mtu.send_mtu = std::min(mtu.send_mtu, mtu_i.send_mtu);
+        }
 
-    std::cout << "mtu recv bytes " << mtu.recv_mtu << std::endl;
-    std::cout << "mtu send bytes " << mtu.send_mtu << std::endl;
+        //use the discovered mtu or clip the users requested mtu
+        mtu.recv_mtu = std::min(size_t(device_addr.cast<double>("recv_frame_size", 9000)), mtu.recv_mtu);
+        mtu.send_mtu = std::min(size_t(device_addr.cast<double>("send_frame_size", 9000)), mtu.send_mtu);
 
-    //use the discovered mtu if not specified by the user
-    if (not device_addr.has_key("recv_frame_size"))
         device_addr["recv_frame_size"] = boost::lexical_cast<std::string>(mtu.recv_mtu);
-    if (not device_addr.has_key("send_frame_size"))
         device_addr["send_frame_size"] = boost::lexical_cast<std::string>(mtu.send_mtu);
 
+        std::cout << boost::format("Current recv frame size: %d bytes") % mtu.recv_mtu << std::endl;
+        std::cout << boost::format("Current send frame size: %d bytes") % mtu.send_mtu << std::endl;
+    }
+    catch(const uhd::not_implemented_error &){
+        //just ignore this error, makes older fw work...
+    }
+
+    device_args = separate_device_addr(device_addr); //update args for new frame sizes
+
     //setup rx otw type
     _rx_otw_type.width = 16;
     _rx_otw_type.shift = 0;