EEPROM burning in UHD. Changed some USB device handle stuff. Added usrp_init_eeprom.cpp. Hacked up the firmware makefile to behave and to generate .bin EEPROM images instead of IHX.

5 files changed, 132 insertions, 28 deletions

diff --git a/host/lib/usrp/usrp1/mboard_impl.cpp b/host/lib/usrp/usrp1/mboard_impl.cpp
index 75129c32f..1409855cb 100644
--- a/host/lib/usrp/usrp1/mboard_impl.cpp
+++ b/host/lib/usrp/usrp1/mboard_impl.cpp
@@ -25,6 +25,7 @@
 #include <uhd/usrp/subdev_props.hpp>
 #include <uhd/utils/warning.hpp>
 #include <uhd/utils/assert.hpp>
+#include <uhd/utils/images.hpp>
 #include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <boost/bind.hpp>
@@ -318,6 +319,16 @@ void usrp1_impl::mboard_get(const wax::obj &key_, wax::obj &val)
  **********************************************************************/
 void usrp1_impl::mboard_set(const wax::obj &key, const wax::obj &val)
 {
+    if(key.type() == typeid(std::string)) {
+      if(key.as<std::string>() == "load_eeprom") {
+        std::string usrp1_fpga_image = val.as<std::string>();
+        std::cout << "USRP1 EEPROM image: " << usrp1_fpga_image << std::endl;
+        _ctrl_transport->usrp_load_eeprom(val.as<std::string>());
+      }
+
+      return;
+   	}
+
     //handle the get request conditioned on the key
     switch(key.as<mboard_prop_t>()){
 
diff --git a/host/lib/usrp/usrp1/usrp1_ctrl.cpp b/host/lib/usrp/usrp1/usrp1_ctrl.cpp
index 98226b738..451129ef5 100644
--- a/host/lib/usrp/usrp1/usrp1_ctrl.cpp
+++ b/host/lib/usrp/usrp1/usrp1_ctrl.cpp
@@ -25,6 +25,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <cstring>
 
 using namespace uhd;
 
@@ -203,7 +204,7 @@ public:
                     return -1; 
                 }
             }  
-            //type 0x00 is end 
+            //type 0x01 is end 
             else if (type == 0x01) {
                 usrp_control_write(FX2_FIRMWARE_LOAD, 0xe600, 0,
                                    &reset_n, 1);
@@ -283,6 +284,55 @@ public:
         return 0; 
     }
 
+    int usrp_load_eeprom(std::string filestring)
+    {
+        const char *filename = filestring.c_str();
+        const uint16_t i2c_addr = 0x50;
+
+        //FIXME: verify types
+        int len;
+        unsigned int addr;
+        unsigned char data[256];
+        unsigned char sendbuf[17];
+
+        int ret;
+        std::ifstream file;
+        file.open(filename, std::ifstream::in);
+
+        if (!file.good()) {
+            std::cerr << "cannot open EEPROM input file" << std::endl;
+            return -1; 
+        }
+
+        file.read((char *)data, 256);
+        len = file.gcount();
+
+        if(len == 256) {
+          std::cerr << "error: image size too large" << std::endl;
+          file.close();
+          return -1;
+        }
+
+        const int pagesize = 16;
+        addr = 0;
+        while(len > 0) {
+          sendbuf[0] = addr;
+          memcpy(sendbuf+1, &data[addr], len > pagesize ? pagesize : len);
+          ret = usrp_i2c_write(i2c_addr, sendbuf, (len > pagesize ? pagesize : len)+1);
+          if (ret < 0) {
+            std::cerr << "error: usrp_i2c_write failed: ";
+            std::cerr << ret << std::endl;
+            file.close();
+            return -1; 
+          }
+          addr += pagesize;
+          len -= pagesize;
+          boost::this_thread::sleep(boost::posix_time::milliseconds(100));
+        }
+        file.close();
+        return 0;
+    }
+
 
     int usrp_set_led(int led_num, bool on)
     {
@@ -371,6 +421,17 @@ public:
         return usrp_control_write(request, value, index, 0, 0);
     }
 
+    int usrp_i2c_write(boost::uint16_t i2c_addr, unsigned char *buf, boost::uint16_t len)
+    {
+        return usrp_control_write(VRQ_I2C_WRITE, i2c_addr, 0, buf, len);
+    }
+
+    int usrp_i2c_read(boost::uint16_t i2c_addr, unsigned char *buf, boost::uint16_t len)
+    {
+        return usrp_control_read(VRQ_I2C_READ, i2c_addr, 0, buf, len);
+    }
+
+
 
 private:
     uhd::transport::usb_control::sptr _ctrl_transport;
diff --git a/host/lib/usrp/usrp1/usrp1_ctrl.hpp b/host/lib/usrp/usrp1/usrp1_ctrl.hpp
index deedec4e8..a02d9f96c 100644
--- a/host/lib/usrp/usrp1/usrp1_ctrl.hpp
+++ b/host/lib/usrp/usrp1/usrp1_ctrl.hpp
@@ -50,6 +50,13 @@ public:
     virtual int usrp_load_fpga(std::string filename) = 0;
 
     /*!
+     * Load USB descriptor file in Intel HEX format into EEPROM
+     * \param filename name of EEPROM image 
+     * \return 0 on success, error code otherwise
+     */
+    virtual int usrp_load_eeprom(std::string filestring) = 0;
+
+    /*!
      * Set led usrp 
      * \param led_num which LED to control (0 or 1)
      * \param on turn LED on or off
@@ -127,6 +134,30 @@ public:
                                    unsigned char *buff,
                                    boost::uint16_t length) = 0;
 
+    /*!
+     * Perform an I2C write
+     * \param i2c_addr I2C device address
+     * \param buf data to be written 
+     * \param len length of data in bytes
+     * \return number of bytes written or error 
+     */
+
+    virtual int usrp_i2c_write(boost::uint16_t i2c_addr,
+                               unsigned char *buf, 
+                               boost::uint16_t len) = 0;
+
+    /*!
+     * Perform an I2C read
+     * \param i2c_addr I2C device address
+     * \param buf data to be read 
+     * \param len length of data in bytes
+     * \return number of bytes read or error 
+     */
+
+    virtual int usrp_i2c_read(boost::uint16_t i2c_addr,
+                               unsigned char *buf, 
+                               boost::uint16_t len) = 0;
+
 };
 
 #endif /* INCLUDED_USRP_CTRL_HPP */
diff --git a/host/lib/usrp/usrp1/usrp1_iface.cpp b/host/lib/usrp/usrp1/usrp1_iface.cpp
index 8756a21c9..4bc18dd16 100644
--- a/host/lib/usrp/usrp1/usrp1_iface.cpp
+++ b/host/lib/usrp/usrp1/usrp1_iface.cpp
@@ -109,18 +109,19 @@ public:
      ******************************************************************/
     static const size_t max_i2c_data_bytes = 64;
 
+    //TODO: make this handle EEPROM page sizes. right now you can't write over a 16-byte boundary.
+    //to accomplish this you'll have to have addr offset as a separate parameter.
+
     void write_i2c(boost::uint8_t addr, const byte_vector_t &bytes)
     {
         UHD_ASSERT_THROW(bytes.size() < max_i2c_data_bytes);
 
         unsigned char buff[max_i2c_data_bytes];
-        std::copy(bytes.begin(), bytes.end(), buff); 
+        std::copy(bytes.begin(), bytes.end(), buff);
 
-        int ret = _ctrl_transport->usrp_control_write(VRQ_I2C_WRITE,
-                                                      addr & 0xff,
-                                                      0,
-                                                      buff,
-                                                      bytes.size());
+        int ret = _ctrl_transport->usrp_i2c_write(addr & 0xff,
+                                             buff,
+                                             bytes.size());
 
         // TODO throw and catch i2c failures during eeprom read
         if (iface_debug && (ret < 0))
@@ -132,11 +133,9 @@ public:
         UHD_ASSERT_THROW(num_bytes < max_i2c_data_bytes);
 
         unsigned char buff[max_i2c_data_bytes];
-        int ret = _ctrl_transport->usrp_control_read(VRQ_I2C_READ,
-                                                     addr & 0xff,
-                                                     0,
-                                                     buff,
-                                                     num_bytes);
+        int ret = _ctrl_transport->usrp_i2c_read(addr & 0xff,
+                                            buff,
+                                            num_bytes);
 
         // TODO throw and catch i2c failures during eeprom read
         if (iface_debug && ((ret < 0) || (unsigned)ret < (num_bytes))) {
diff --git a/host/lib/usrp/usrp1/usrp1_impl.cpp b/host/lib/usrp/usrp1/usrp1_impl.cpp
index 3c3306525..8ad148274 100644
--- a/host/lib/usrp/usrp1/usrp1_impl.cpp
+++ b/host/lib/usrp/usrp1/usrp1_impl.cpp
@@ -34,6 +34,11 @@ using namespace uhd;
 using namespace uhd::usrp;
 using namespace uhd::transport;
 
+const boost::uint16_t USRP1_VENDOR_ID  = 0xfffe;
+const boost::uint16_t USRP1_PRODUCT_ID = 0x0002;
+const boost::uint16_t FX2_VENDOR_ID    = 0x04b4;
+const boost::uint16_t FX2_PRODUCT_ID   = 0x8613;
+
 const std::vector<usrp1_impl::dboard_slot_t> usrp1_impl::_dboard_slots = boost::assign::list_of
     (usrp1_impl::DBOARD_SLOT_A)(usrp1_impl::DBOARD_SLOT_B)
 ;
@@ -54,33 +59,32 @@ static device_addrs_t usrp1_find(const device_addr_t &hint)
     );
     std::cout << "USRP1 firmware image: " << usrp1_fw_image << std::endl;
 
+    boost::uint16_t vid = hint.has_key("uninit") ? FX2_VENDOR_ID : USRP1_VENDOR_ID;
+    boost::uint16_t pid = hint.has_key("uninit") ? FX2_PRODUCT_ID : USRP1_PRODUCT_ID;
+
     //see what we got on the USB bus
     std::vector<usb_device_handle::sptr> device_list =
-        usb_device_handle::get_device_list();
+        usb_device_handle::get_device_list(vid, pid);
+
+    if(device_list.size() == 0) return usrp1_addrs; //return nothing if no USRPs found
 
     //find the usrps and load firmware
     BOOST_FOREACH(usb_device_handle::sptr handle, device_list) {
-        if (handle->get_vendor_id() == 0xfffe &&
-            handle->get_product_id() == 0x0002) {
-
             usb_control::sptr ctrl_transport = usb_control::make(handle);
             usrp_ctrl::sptr usrp_ctrl = usrp_ctrl::make(ctrl_transport);
             usrp_ctrl->usrp_load_firmware(usrp1_fw_image);
-        }
     }
 
-    //get descriptors again with serial number
-    device_list = usb_device_handle::get_device_list();
+    //get descriptors again with serial number, but using the initialized VID/PID now since we have firmware
+    vid = USRP1_VENDOR_ID;
+    pid = USRP1_PRODUCT_ID;
+    device_list = usb_device_handle::get_device_list(vid, pid);
 
     BOOST_FOREACH(usb_device_handle::sptr handle, device_list) {
-        if (handle->get_vendor_id() == 0xfffe &&
-            handle->get_product_id() == 0x0002) {
-
             device_addr_t new_addr;
             new_addr["type"] = "usrp1";
             new_addr["serial"] = handle->get_serial();
             usrp1_addrs.push_back(new_addr);
-        }
     }
 
     return usrp1_addrs;
@@ -99,17 +103,15 @@ static device::sptr usrp1_make(const device_addr_t &device_addr)
 
     //try to match the given device address with something on the USB bus
     std::vector<usb_device_handle::sptr> device_list =
-        usb_device_handle::get_device_list();
+        usb_device_handle::get_device_list(USRP1_VENDOR_ID, USRP1_PRODUCT_ID);
 
     //create data and control transports
     usb_zero_copy::sptr data_transport;
     usrp_ctrl::sptr usrp_ctrl;
 
-    BOOST_FOREACH(usb_device_handle::sptr handle, device_list) {
-        if (handle->get_vendor_id() == 0xfffe &&
-            handle->get_product_id() == 0x0002 &&
-            handle->get_serial() == device_addr["serial"]) {
 
+    BOOST_FOREACH(usb_device_handle::sptr handle, device_list) {
+        if (handle->get_serial() == device_addr["serial"]) {
             usb_control::sptr ctrl_transport = usb_control::make(handle);
             usrp_ctrl = usrp_ctrl::make(ctrl_transport);
             usrp_ctrl->usrp_load_fpga(usrp1_fpga_image);