Added usrp2 impl for the guts of the usrp2 handling.

The top level usrp2 will contain an impl and forward calls to it.

6 files changed, 220 insertions, 42 deletions

diff --git a/lib/usrp/dboard/id.cpp b/lib/usrp/dboard/id.cpp
index 0f173ef14..80162240e 100644
--- a/lib/usrp/dboard/id.cpp
+++ b/lib/usrp/dboard/id.cpp
@@ -24,6 +24,7 @@ using namespace uhd::usrp::dboard;
 std::ostream& operator<<(std::ostream &os, const dboard_id_t &id){
     //map the dboard ids to string representations
     uhd::dict<dboard_id_t, std::string> id_to_str;
+    id_to_str[ID_NONE]     = "none";
     id_to_str[ID_BASIC_TX] = "basic tx";
     id_to_str[ID_BASIC_RX] = "basic rx";
 
diff --git a/lib/usrp/dboard/manager.cpp b/lib/usrp/dboard/manager.cpp
index f6d9a718e..4a675fd0b 100644
--- a/lib/usrp/dboard/manager.cpp
+++ b/lib/usrp/dboard/manager.cpp
@@ -42,6 +42,8 @@ static void register_internal_dboards(void){
     static bool called = false;
     if (called) return; called = true;
     //register the known dboards (dboard id, constructor, subdev names)
+    manager::register_subdevs(ID_NONE,     &basic_tx::make, list_of(""));   //for none, make a basic tx
+    manager::register_subdevs(ID_NONE,     &basic_rx::make, list_of("ab")); //for none, make a basic rx (one subdev)
     manager::register_subdevs(ID_BASIC_TX, &basic_tx::make, list_of(""));
     manager::register_subdevs(ID_BASIC_RX, &basic_rx::make, list_of("a")("b")("ab"));
 }
diff --git a/lib/usrp/mboard/usrp2.cpp b/lib/usrp/mboard/usrp2.cpp
index f744dce59..6bd9bee83 100644
--- a/lib/usrp/mboard/usrp2.cpp
+++ b/lib/usrp/mboard/usrp2.cpp
@@ -17,11 +17,13 @@
 
 #include <uhd/usrp/mboard/usrp2.hpp>
 #include <uhd/device.hpp>
+#include <uhd/transport/udp.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/format.hpp>
 #include <boost/thread.hpp>
 #include <netinet/in.h>
-#include "usrp2_fw_common.h"
+#include "usrp2_impl.hpp"
+//#include "usrp2_dboard_interface.hpp"
 
 using namespace uhd::usrp::mboard;
 
@@ -74,28 +76,26 @@ uhd::device_addrs_t usrp2::discover(const device_addr_t &hint){
  * Structors
  **********************************************************************/
 usrp2::usrp2(const device_addr_t &device_addr){
-    //initialize the transports for udp
-    _udp_ctrl_transport = uhd::transport::udp::sptr(
+    //create a control transport
+    uhd::transport::udp::sptr ctrl_transport(
         new uhd::transport::udp(
             device_addr["addr"],
             boost::lexical_cast<std::string>(USRP2_UDP_CTRL_PORT)
         )
     );
-    _udp_data_transport = uhd::transport::udp::sptr(
+
+    //create a data transport
+    uhd::transport::udp::sptr data_transport(
         new uhd::transport::udp(
             device_addr["addr"],
             boost::lexical_cast<std::string>(USRP2_UDP_DATA_PORT)
         )
     );
-    //grab the dboard ids over the control line
-    usrp2_ctrl_data_t out_data;
-    out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_DBOARD_IDS_BRO);
-    usrp2_ctrl_data_t in_data = _ctrl_send_and_recv(out_data);
-    //TODO assert the control data id response
-    std::cout << boost::format("rx id 0x%.2x, tx id 0x%.2x")
-        % ntohs(in_data.data.dboard_ids.rx_id)
-        % ntohs(in_data.data.dboard_ids.tx_id) << std::endl;
-    //TODO setup the dboard manager with the dboard ids
+
+    //create the usrp2 implementation guts
+    _impl = usrp2_impl::sptr(
+        new usrp2_impl(ctrl_transport, data_transport)
+    );
 }
 
 usrp2::~usrp2(void){
@@ -103,35 +103,6 @@ usrp2::~usrp2(void){
 }
 
 /***********************************************************************
- * Transactions
- **********************************************************************/
-template <class T> T usrp2::_ctrl_send_and_recv(const T &out_data){
-    //fill in the seq number and send
-    T out_copy = out_data;
-    out_copy.seq = htonl(++_ctrl_seq_num);
-    _udp_ctrl_transport->send(boost::asio::buffer(&out_copy, sizeof(T)));
-
-    //loop and recieve until the time is up
-    size_t num_timeouts = 0;
-    while(true){
-        uhd::shared_iovec iov = _udp_ctrl_transport->recv();
-        if (iov.len < sizeof(T)){
-            //sleep a little so we dont burn cpu
-            if (num_timeouts++ > 50) break;
-            boost::this_thread::sleep(boost::posix_time::milliseconds(1));
-        }else{
-            //handle the received data
-            T in_data = *reinterpret_cast<const T *>(iov.base);
-            if (ntohl(in_data.seq) == _ctrl_seq_num){
-                return in_data;
-            }
-            //didnt get seq, continue on...
-        }
-    }
-    throw std::runtime_error("usrp2 no control response");
-}
-
-/***********************************************************************
  * Get Properties
  **********************************************************************/
 void usrp2::get(const wax::obj &, wax::obj &){
diff --git a/lib/usrp/mboard/usrp2_dboard_interface.hpp b/lib/usrp/mboard/usrp2_dboard_interface.hpp
new file mode 100644
index 000000000..24dff797b
--- /dev/null
+++ b/lib/usrp/mboard/usrp2_dboard_interface.hpp
@@ -0,0 +1,66 @@
+//
+// Copyright 2010 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
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/dboard/interface.hpp>
+#include "usrp2_impl.hpp"
+
+#ifndef INCLUDED_USRP2_DBOARD_INTERFACE_HPP
+#define INCLUDED_USRP2_DBOARD_INTERFACE_HPP
+
+class usrp2_dboard_interface : public uhd::usrp::dboard::interface{
+public:
+    usrp2_dboard_interface(const usrp2_impl *impl) : _impl(impl){
+        /* NOP */
+    }
+
+    ~usrp2_dboard_interface(void){
+        /* NOP */
+    }
+
+    void write_aux_dac(int, int){}
+
+    int read_aux_adc(int){return 0;}
+
+    void set_atr_reg(gpio_bank_t, uint16_t, uint16_t, uint16_t){}
+
+    void set_gpio_ddr(gpio_bank_t, uint16_t, uint16_t){}
+
+    void write_gpio(gpio_bank_t, uint16_t, uint16_t){}
+
+    uint16_t read_gpio(gpio_bank_t){return 0;}
+
+    void write_i2c (int, const std::string &){}
+
+    std::string read_i2c (int, size_t){return "";}
+
+    void write_spi (spi_dev_t, spi_push_t, const std::string &){}
+
+    std::string read_spi (spi_dev_t, spi_latch_t, size_t){return "";}
+
+    double get_rx_clock_rate(void){
+        return 100e6;
+    }
+
+    double get_tx_clock_rate(void){
+        return 100e6;
+    }
+
+private:
+    const usrp2_impl *_impl;
+};
+
+#endif /* INCLUDED_USRP2_DBOARD_INTERFACE_HPP */
diff --git a/lib/usrp/mboard/usrp2_impl.cpp b/lib/usrp/mboard/usrp2_impl.cpp
new file mode 100644
index 000000000..a9c58c4fe
--- /dev/null
+++ b/lib/usrp/mboard/usrp2_impl.cpp
@@ -0,0 +1,88 @@
+//
+// Copyright 2010 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
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <boost/thread.hpp>
+#include <boost/format.hpp>
+#include <uhd/utils.hpp>
+#include <iostream>
+#include "usrp2_impl.hpp"
+#include "usrp2_dboard_interface.hpp"
+
+using namespace uhd::usrp;
+
+usrp2_impl::usrp2_impl(
+    uhd::transport::udp::sptr ctrl_transport,
+    uhd::transport::udp::sptr data_transport
+){
+    _ctrl_transport = ctrl_transport;
+    _data_transport = data_transport;
+
+    //grab the dboard ids over the control line
+    usrp2_ctrl_data_t out_data;
+    out_data.id = htonl(USRP2_CTRL_ID_GIVE_ME_YOUR_DBOARD_IDS_BRO);
+    usrp2_ctrl_data_t in_data = ctrl_send_and_recv(out_data);
+    ASSERT_THROW(htonl(in_data.id) == USRP2_CTRL_ID_THESE_ARE_MY_DBOARD_IDS_DUDE);
+    std::cout << boost::format("rx id 0x%.2x, tx id 0x%.2x")
+        % ntohs(in_data.data.dboard_ids.rx_id)
+        % ntohs(in_data.data.dboard_ids.tx_id) << std::endl;
+
+    //extract the dboard ids an convert them to enums
+    dboard::dboard_id_t rx_dboard_id = static_cast<dboard::dboard_id_t>(
+        ntohs(in_data.data.dboard_ids.rx_id)
+    );
+    dboard::dboard_id_t tx_dboard_id = static_cast<dboard::dboard_id_t>(
+        ntohs(in_data.data.dboard_ids.tx_id)
+    );
+
+    //create a new dboard interface and manager
+    _dboard_interface = dboard::interface::sptr(
+        new usrp2_dboard_interface(this)
+    );
+    _dboard_manager = dboard::manager::sptr(
+        new dboard::manager(rx_dboard_id, tx_dboard_id, _dboard_interface)
+    );
+}
+
+usrp2_impl::~usrp2_impl(void){
+    /* NOP */
+}
+
+usrp2_ctrl_data_t usrp2_impl::ctrl_send_and_recv(const usrp2_ctrl_data_t &out_data){
+    //fill in the seq number and send
+    usrp2_ctrl_data_t out_copy = out_data;
+    out_copy.seq = htonl(++_ctrl_seq_num);
+    _ctrl_transport->send(boost::asio::buffer(&out_copy, sizeof(usrp2_ctrl_data_t)));
+
+    //loop and recieve until the time is up
+    size_t num_timeouts = 0;
+    while(true){
+        uhd::shared_iovec iov = _ctrl_transport->recv();
+        if (iov.len < sizeof(usrp2_ctrl_data_t)){
+            //sleep a little so we dont burn cpu
+            if (num_timeouts++ > 50) break;
+            boost::this_thread::sleep(boost::posix_time::milliseconds(1));
+        }else{
+            //handle the received data
+            usrp2_ctrl_data_t in_data = *reinterpret_cast<const usrp2_ctrl_data_t *>(iov.base);
+            if (ntohl(in_data.seq) == _ctrl_seq_num){
+                return in_data;
+            }
+            //didnt get seq, continue on...
+        }
+    }
+    throw std::runtime_error("usrp2 no control response");
+}
diff --git a/lib/usrp/mboard/usrp2_impl.hpp b/lib/usrp/mboard/usrp2_impl.hpp
new file mode 100644
index 000000000..0c2c2292e
--- /dev/null
+++ b/lib/usrp/mboard/usrp2_impl.hpp
@@ -0,0 +1,50 @@
+//
+// Copyright 2010 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
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/usrp/dboard/manager.hpp>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+#include <uhd/transport/udp.hpp>
+#include "usrp2_fw_common.h"
+
+#ifndef INCLUDED_USRP2_IMPL_HPP
+#define INCLUDED_USRP2_IMPL_HPP
+
+class usrp2_impl : boost::noncopyable{
+public:
+    typedef boost::shared_ptr<usrp2_impl> sptr;
+
+    usrp2_impl(
+        uhd::transport::udp::sptr ctrl_transport,
+        uhd::transport::udp::sptr data_transport
+    );
+
+    ~usrp2_impl(void);
+
+    usrp2_ctrl_data_t ctrl_send_and_recv(const usrp2_ctrl_data_t &);
+
+private:
+    uhd::transport::udp::sptr _ctrl_transport;
+    uhd::transport::udp::sptr _data_transport;
+
+    uint32_t _ctrl_seq_num;
+
+    uhd::usrp::dboard::manager::sptr   _dboard_manager;
+    uhd::usrp::dboard::interface::sptr _dboard_interface;
+};
+
+#endif /* INCLUDED_USRP2_IMPL_HPP */