uhd

    f = open(filename, 'rb')

    bytes = f.read()

    start_addr = 0 #prove me wrong

    image = rom_header + code_header + [ord(c) for c in bytes] + trailer

    return image 

    usage = "usage: %prog -r REV [options] bootfile.bin outfile.bin"

    if len (args) != 2:

    infile = args[0]

    outfile = args[1]

    image = "".join(chr(c) for c in build_eeprom_image(infile, options.rev))

    f = open(outfile, 'wb')

    f.write(str(image))

    f.close()  

#firmwaredir = $(prefix)/share/uhd/images

#firmware_DATA = usrp1_fw.ihx

#eepromdir = $(firmwaredir)

#eepromfile = eeprom_boot.ihx

#eeprom_DATA = usrp1_eeprom.bin

usrp1_eeprom.bin: eeprom_boot.bin

	$(PYTHON) ../common/build_eeprom.py -r4 $< $@

eeprom_boot.bin: eeprom_boot.ihx

	objcopy -I ihex -O binary $< $@

	*.ihx *.lnk *.lst *.map *.mem *.rel *.rst *.sym *.asm *.lib	*.bin \

	usrp_gpif.c usrp_gpif_inline.h

	*.ihx *.lnk *.lst *.map *.mem *.rel *.rst *.sym *.asm *.lib *.bin

all: usrp_gpif.c std.ihx usrp1_eeprom.bin

     * \return a vector of USB device handles that match vid and pid

    static UHD_API std::vector<usb_device_handle::sptr> get_device_list(boost::uint16_t vid, boost::uint16_t pid);

    libusb_device **libusb_dev_list;

    size_t dev_cnt = libusb_get_device_list(ctx, &libusb_dev_list);

    for (size_t i = 0; i < dev_cnt; i++) {

        libusb_device *dev = libusb_dev_list[i];

//note: changed order of checks so it only tries to get_serial and get_device_address if vid and pid match

//doing this so it doesn't try to open the device if it's not ours

    if (serial != get_serial(dev))

        return false;

#include <iostream>

std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(boost::uint16_t vid, boost::uint16_t pid)

    libusb_device** libusb_device_list;

    libusb_device_descriptor desc;

    size_t dev_size = libusb_get_device_list(ctx, &libusb_device_list);

    for (size_t i = 0; i < dev_size; i++) {

        if(libusb_get_device_descriptor(dev, &desc) < 0) {

          UHD_ASSERT_THROW("USB: failed to get device descriptor");

        }

        if(desc.idVendor == vid && desc.idProduct == pid) {

          device_handle_list.push_back(make_usb_device_handle(dev));

        }

#include <uhd/utils/images.hpp>

    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;

   	}

#include <cstring>

            //type 0x01 is end 

    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_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);

    }

     * 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;

    /*!

    /*!

     * 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;

    //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.

        std::copy(bytes.begin(), bytes.end(), buff);

        int ret = _ctrl_transport->usrp_i2c_write(addr & 0xff,

                                             buff,

                                             bytes.size());

        int ret = _ctrl_transport->usrp_i2c_read(addr & 0xff,

                                            buff,

                                            num_bytes);

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;

    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;

        usb_device_handle::get_device_list(vid, pid);

    if(device_list.size() == 0) return usrp1_addrs; //return nothing if no USRPs found

    //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);

        usb_device_handle::get_device_list(USRP1_VENDOR_ID, USRP1_PRODUCT_ID);

    BOOST_FOREACH(usb_device_handle::sptr handle, device_list) {

        if (handle->get_serial() == device_addr["serial"]) {

ADD_EXECUTABLE(usrp_init_eeprom usrp_init_eeprom.cpp)

TARGET_LINK_LIBRARIES(usrp_init_eeprom uhd)

    usrp_init_eeprom

//

// 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/utils/safe_main.hpp>

#include <uhd/device.hpp>

#include <uhd/usrp/device_props.hpp>

#include <boost/program_options.hpp>

#include <boost/format.hpp>

#include <iostream>

namespace po = boost::program_options;

int UHD_SAFE_MAIN(int argc, char *argv[]){

    po::options_description desc("Allowed options");

    desc.add_options()

        ("help", "help message")

        ("image", po::value<std::string>(), "IHX image file")

    ;

    po::variables_map vm;

    po::store(po::parse_command_line(argc, argv, desc), vm);

    po::notify(vm); 

    //print the help message

    if (vm.count("help")){

        std::cout << boost::format("USRP EEPROM initialization %s") % desc << std::endl;

        return ~0;

    }

    //load the options into the address

    uhd::device_addr_t device_addr;

    device_addr["type"] = "usrp1";

    device_addr["uninit"] = "yeah"; //tell find to look for an uninitialized FX2

    //find and create a control transport to do the writing.

    uhd::device_addrs_t found_addrs = uhd::device::find(device_addr);

    if (found_addrs.size() == 0){

        std::cerr << "No uninitialized USRP devices found" << std::endl;

        return ~0;

    }

    for (size_t i = 0; i < found_addrs.size(); i++){

        std::cout << "Writing EEPROM data..." << std::endl;

        //uhd::device_addrs_t devs = uhd::device::find(found_addrs[i]);

        uhd::device::sptr dev = uhd::device::make(found_addrs[i]);

        wax::obj mb = (*dev)[uhd::usrp::DEVICE_PROP_MBOARD];

        mb[std::string("load_eeprom")] = vm["image"].as<std::string>();

    }

    std::cout << "Power-cycle the usrp for the changes to take effect." << std::endl;

    return 0;

}