diff options
Diffstat (limited to 'host/utils')
| -rw-r--r-- | host/utils/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | host/utils/usrp_n2xx_simple_net_burner.cpp | 517 | ||||
| -rw-r--r-- | host/utils/usrp_simple_burner_utils.hpp | 99 |
3 files changed, 617 insertions, 0 deletions
diff --git a/host/utils/CMakeLists.txt b/host/utils/CMakeLists.txt index 763bb47bc..9e997071e 100644 --- a/host/utils/CMakeLists.txt +++ b/host/utils/CMakeLists.txt @@ -41,6 +41,7 @@ SET(util_share_sources query_gpsdo_sensors.cpp usrp_burn_db_eeprom.cpp usrp_burn_mb_eeprom.cpp + usrp_n2xx_simple_net_burner.cpp ) IF(ENABLE_USB) diff --git a/host/utils/usrp_n2xx_simple_net_burner.cpp b/host/utils/usrp_n2xx_simple_net_burner.cpp new file mode 100644 index 000000000..223021510 --- /dev/null +++ b/host/utils/usrp_n2xx_simple_net_burner.cpp @@ -0,0 +1,517 @@ +// +// Copyright 2012 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 <iostream> +#include <map> +#include <fstream> +#include <time.h> +#include <vector> + +#include <boost/foreach.hpp> +#include <boost/asio.hpp> +#include <boost/program_options.hpp> +#include <boost/assign.hpp> +#include <boost/assign/list_of.hpp> +#include <boost/format.hpp> +#include <boost/algorithm/string/erase.hpp> +#include <boost/filesystem.hpp> +#include <boost/thread/thread.hpp> + +#include "usrp_simple_burner_utils.hpp" +#include <uhd/exception.hpp> +#include <uhd/transport/if_addrs.hpp> +#include <uhd/transport/udp_simple.hpp> +#include <uhd/utils/byteswap.hpp> +#include <uhd/utils/images.hpp> +#include <uhd/utils/safe_main.hpp> +#include <uhd/utils/safe_call.hpp> + +namespace po = boost::program_options; +using namespace boost::algorithm; +using namespace uhd; +using namespace uhd::transport; + +//Mapping revision numbers to filenames +std::map<boost::uint32_t, std::string> filename_map = boost::assign::map_list_of + (0xa, "n200_r3") + (0x100a, "n200_r4") + (0x10a, "n210_r3") + (0x110a, "n210_r4") +; + +//For non-standard images not covered by uhd::find_image_path() +bool does_image_exist(std::string image_filepath){ + + std::ifstream ifile((char*)image_filepath.c_str()); + return ifile; +} + +//Checks for existence of file and validity of filename +void check_image_file_validity(std::string rev_str, std::string default_fpga_filename, std::string default_fw_filename, + std::string fpga_path, std::string fw_path, bool burn_fpga, bool burn_fw, bool use_custom_fpga, bool use_custom_fw){ + + if(burn_fpga){ + if(use_custom_fpga){ + //Check for existence of file + if(!does_image_exist(fpga_path)) throw std::runtime_error(str(boost::format("No file at specified FPGA path: %s") % fw_path)); + + //Check to find rev_str in filename + boost::filesystem::path custom_fpga_path(fpga_path); + if(custom_fpga_path.filename().string().find("fw") != std::string::npos){ + throw std::runtime_error(str(boost::format("Invalid FPGA image filename at path: %s\nFilename indicates that this is a firmware image.") + % fpga_path)); + } + if(custom_fpga_path.filename().string().find(rev_str) == std::string::npos){ + throw std::runtime_error(str(boost::format("Invalid firmware image filename at path: %s\nFilename must contain '%s' to be considered valid for this model.") + % fw_path % rev_str)); + } + } + //Check for image in UHD_IMAGES_DIR + else find_image_path(default_fpga_filename); + } + if(burn_fw){ + if(use_custom_fw){ + //Check for existence of file + if(!does_image_exist(fw_path)) throw std::runtime_error(str(boost::format("No file at specified firmware path: %s") % fw_path)); + + //Check to find truncated rev_str in filename + boost::filesystem::path custom_fw_path(fw_path); + if(custom_fw_path.filename().string().find("fpga") != std::string::npos){ + throw std::runtime_error(str(boost::format("Invalid firmware image filename at path: %s\nFilename indicates that this is an FPGA image.") + % fw_path)); + } + if(custom_fw_path.filename().string().find(erase_tail_copy(rev_str,3)) == std::string::npos){ + throw std::runtime_error(str(boost::format("Invalid firmware image filename at path: %s\nFilename must contain '%s' to be considered valid for this model.") + % fw_path % erase_tail_copy(rev_str,3))); + } + } + //Check for image in UHD_IMAGES_DIR + else find_image_path(default_fw_filename); + } +} + +//Basic checks of images to make sure they're actually images +void check_image_binary_validity(std::string fpga_path, std::string fw_path, bool burn_fpga, bool burn_fw){ + + if(burn_fpga){ + std::ifstream fpga_image((char*)fpga_path.c_str(), std::ios::binary); + + //Check size of image + fpga_image.seekg(0, std::ios::end); + int fpga_size = fpga_image.tellg(); + if(fpga_size > FPGA_IMAGE_SIZE_BYTES){ + throw std::runtime_error(str(boost::format("FPGA image is too large. %d > %d") % fpga_size % FPGA_IMAGE_SIZE_BYTES)); + } + + //Check sequence of bytes in image + char fpga_image_buffer[2]; + bool fpga_image_is_good = false; + for(int i = 0; i < 63; i++){ + fpga_image.seekg(i, std::ios::beg); + fpga_image.read(fpga_image_buffer,2); + + if((unsigned char)fpga_image_buffer[0] == 255) continue; + else if((unsigned char)fpga_image_buffer[0] == 170 and + (unsigned char)fpga_image_buffer[1] == 153){ + fpga_image_is_good = true; + break; + } + } + if(!fpga_image_is_good) throw std::runtime_error("Not a valid FPGA image."); + + fpga_image.close(); + } + if(burn_fw){ + std::ifstream fw_image((char*)fw_path.c_str(), std::ios::binary); + + //Check size of image + fw_image.seekg(0, std::ios::end); + int fw_size = fw_image.tellg(); + if(fw_size > FW_IMAGE_SIZE_BYTES){ + throw std::runtime_error(str(boost::format("Firmware image is too large. %d > %d") % fw_size % FW_IMAGE_SIZE_BYTES)); + } + + //Check first four bytes of image + char fw_image_buffer[4]; + fw_image.seekg(0, std::ios::beg); + fw_image.read(fw_image_buffer, 4); + for(int i = 0; i < 4; i++) if(int(fw_image_buffer[i]) != 11) throw std::runtime_error("Not a valid firmware image."); + + fw_image.close(); + } +} + +boost::uint32_t* get_flash_info(std::string ip_addr){ + + boost::uint32_t *flash_info = new boost::uint32_t[2]; + boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu]; + const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem); + + udp_simple::sptr udp_transport = udp_simple::make_connected(ip_addr, BOOST_STRINGIZE(USRP2_UDP_UPDATE_PORT)); + usrp2_fw_update_data_t get_flash_info_pkt = usrp2_fw_update_data_t(); + get_flash_info_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION); + get_flash_info_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_WATS_TEH_FLASH_INFO_LOL); + udp_transport->send(boost::asio::buffer(&get_flash_info_pkt, sizeof(get_flash_info_pkt))); + + //Loop and receive until the timeout + while(true){ + size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem)); + if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_HERES_TEH_FLASH_INFO_OMG){ + flash_info[0] = ntohl(update_data_in->data.flash_info_args.sector_size_bytes); + flash_info[1] = ntohl(update_data_in->data.flash_info_args.memory_size_bytes); + } + if(len == 0) break; + } + + return flash_info; +} + +void erase_image(udp_simple::sptr udp_transport, bool is_fw, boost::uint32_t memory_size){ + + //Making sure this won't attempt to erase past end of device + if(is_fw){ + if(PROD_FW_IMAGE_LOCATION_ADDR+FW_IMAGE_SIZE_BYTES > memory_size) throw std::runtime_error("Cannot erase past end of device."); + } + else{ + if(PROD_FPGA_IMAGE_LOCATION_ADDR+FPGA_IMAGE_SIZE_BYTES > memory_size) throw std::runtime_error("Cannot erase past end of device."); + } + + //Setting up UDP transport + boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu]; + const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem); + + //Setting up UDP packet + usrp2_fw_update_data_t erase_pkt = usrp2_fw_update_data_t(); + erase_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_ERASE_TEH_FLASHES_LOL); + erase_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION); + if(is_fw){ + erase_pkt.data.flash_args.flash_addr = htonx<boost::uint32_t>(PROD_FW_IMAGE_LOCATION_ADDR); + erase_pkt.data.flash_args.length = htonx<boost::uint32_t>(FW_IMAGE_SIZE_BYTES); + } + else{ + erase_pkt.data.flash_args.flash_addr = htonx<boost::uint32_t>(PROD_FPGA_IMAGE_LOCATION_ADDR); + erase_pkt.data.flash_args.length = htonx<boost::uint32_t>(FPGA_IMAGE_SIZE_BYTES); + } + + //Begin erasing + udp_transport->send(boost::asio::buffer(&erase_pkt, sizeof(erase_pkt))); + size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT); + if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_ERASING_TEH_FLASHES_OMG){ + if(is_fw) std::cout << "Erasing firmware image." << std::endl; + else std::cout << "Erasing FPGA image." << std::endl; + } + else if(ntohl(update_data_in->id) != USRP2_FW_UPDATE_ID_ERASING_TEH_FLASHES_OMG){ + throw std::runtime_error(str(boost::format("Received invalid reply %d from device.\n") % ntohl(update_data_in->id))); + } + + //Check for erase completion + erase_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_R_U_DONE_ERASING_LOL); + while(true){ + udp_transport->send(boost::asio::buffer(&erase_pkt, sizeof(erase_pkt))); + size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT); + if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_IM_DONE_ERASING_OMG){ + if(is_fw) std::cout << boost::format(" * Successfully erased %d bytes at %d.\n") % FW_IMAGE_SIZE_BYTES % PROD_FW_IMAGE_LOCATION_ADDR; + else std::cout << boost::format(" * Successfully erased %d bytes at %d.\n") % FPGA_IMAGE_SIZE_BYTES % PROD_FPGA_IMAGE_LOCATION_ADDR; + break; + } + else if(ntohl(update_data_in->id) != USRP2_FW_UPDATE_ID_NOPE_NOT_DONE_ERASING_OMG){ + throw std::runtime_error(str(boost::format("Received invalid reply %d from device.\n") % ntohl(update_data_in->id))); + } + } +} + +void write_image(udp_simple::sptr udp_transport, bool is_fw, boost::uint8_t* image, boost::uint32_t memory_size, int image_size){ + + boost::uint32_t current_addr; + if(is_fw) current_addr = PROD_FW_IMAGE_LOCATION_ADDR; + else current_addr = PROD_FPGA_IMAGE_LOCATION_ADDR; + + //Making sure this won't attempt to write past end of device + if(current_addr+image_size > memory_size) throw std::runtime_error("Cannot write past end of device."); + + //Setting up UDP transport + boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu]; + const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem); + + //Setting up UDP packet + usrp2_fw_update_data_t write_pkt = usrp2_fw_update_data_t(); + write_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_WRITE_TEH_FLASHES_LOL); + write_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION); + write_pkt.data.flash_args.length = htonx<boost::uint32_t>(FLASH_DATA_PACKET_SIZE); + + //Write image + if(is_fw) std::cout << "Writing firmware image." << std::endl; + else std::cout << "Writing FPGA image." << std::endl; + + for(int i = 0; i < ((image_size/FLASH_DATA_PACKET_SIZE)+1); i++){ + write_pkt.data.flash_args.flash_addr = htonx<boost::uint32_t>(current_addr); + std::copy(image+(i*FLASH_DATA_PACKET_SIZE), image+((i+1)*FLASH_DATA_PACKET_SIZE), write_pkt.data.flash_args.data); + + udp_transport->send(boost::asio::buffer(&write_pkt, sizeof(write_pkt))); + size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT); + if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) != USRP2_FW_UPDATE_ID_WROTE_TEH_FLASHES_OMG){ + throw std::runtime_error(str(boost::format("Invalid reply %d from device.") % ntohl(update_data_in->id))); + } + + current_addr += FLASH_DATA_PACKET_SIZE; + } + std::cout << boost::format(" * Successfully wrote %d bytes.\n") % image_size; +} + +void verify_image(udp_simple::sptr udp_transport, bool is_fw, boost::uint8_t* image, boost::uint32_t memory_size, int image_size){ + + int current_index = 0; + boost::uint32_t current_addr; + if(is_fw) current_addr = PROD_FW_IMAGE_LOCATION_ADDR; + else current_addr = PROD_FPGA_IMAGE_LOCATION_ADDR; + + //Array size needs to be known at runtime, this constant is guaranteed to be larger than any firmware or FPGA image + boost::uint8_t from_usrp[FPGA_IMAGE_SIZE_BYTES]; + + //Making sure this won't attempt to read past end of device + if(current_addr+image_size > memory_size) throw std::runtime_error("Cannot read past end of device."); + + //Setting up UDP transport + boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu]; + const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem); + + //Setting up UDP packet + usrp2_fw_update_data_t verify_pkt = usrp2_fw_update_data_t(); + verify_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_READ_TEH_FLASHES_LOL); + verify_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION); + verify_pkt.data.flash_args.length = htonx<boost::uint32_t>(FLASH_DATA_PACKET_SIZE); + + //Verify image + if(is_fw) std::cout << "Verifying firmware image." << std::endl; + else std::cout << "Verifying FPGA image." << std::endl; + + for(int i = 0; i < ((image_size/FLASH_DATA_PACKET_SIZE)+1); i++){ + verify_pkt.data.flash_args.flash_addr = htonx<boost::uint32_t>(current_addr); + + udp_transport->send(boost::asio::buffer(&verify_pkt, sizeof(verify_pkt))); + size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT); + if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) != USRP2_FW_UPDATE_ID_KK_READ_TEH_FLASHES_OMG){ + throw std::runtime_error(str(boost::format("Invalid reply %d from device.") % ntohl(update_data_in->id))); + } + for(int j = 0; j < FLASH_DATA_PACKET_SIZE; j++) from_usrp[current_index+j] = update_data_in->data.flash_args.data[j]; + + current_addr += FLASH_DATA_PACKET_SIZE; + current_index += FLASH_DATA_PACKET_SIZE; + } + for(int i = 0; i < image_size; i++) if(from_usrp[i] != image[i]) throw std::runtime_error("Image write failed."); + + std::cout << " * Successful." << std::endl; +} + +void reset_usrp(udp_simple::sptr udp_transport){ + + //Set up UDP transport + boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu]; + const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem); + + //Set up UDP packet + usrp2_fw_update_data_t reset_pkt = usrp2_fw_update_data_t(); + reset_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_RESET_MAH_COMPUTORZ_LOL); + reset_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION); + + //Reset USRP + udp_transport->send(boost::asio::buffer(&reset_pkt, sizeof(reset_pkt))); + size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT); + if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_RESETTIN_TEH_COMPUTORZ_OMG){ + throw std::runtime_error("USRP reset failed."); //There should be no response to this UDP packet + } + else std::cout << "Resetting USRP." << std::endl; +} + +int UHD_SAFE_MAIN(int argc, char *argv[]){ + + //Establish user options + std::string fw_path; + std::string ip_addr; + std::string fpga_path; + + po::options_description desc("Allowed options:"); + desc.add_options() + ("help", "Display this help message.") + ("addr", po::value<std::string>(&ip_addr)->default_value("192.168.10.2"), "Specify an IP address.") + ("fw", po::value<std::string>(&fw_path), "Specify a filepath for a custom firmware image.") + ("fpga", po::value<std::string>(&fpga_path), "Specify a filepath for a custom FPGA image.") + ("no_fw", "Do not burn a firmware image.") + ("no_fpga", "Do not burn an FPGA image.") + ("list", "List available N2XX USRP devices.") + ; + po::variables_map vm; + po::store(po::parse_command_line(argc, argv, desc), vm); + po::notify(vm); + + //Apply options + if(vm.count("help") > 0){ + std::cout << boost::format("N2XX Simple Net Burner\n"); + std::cout << boost::format("Automatically detects and burns standard firmware and FPGA images onto USRP N2XX devices.\n"); + std::cout << boost::format("Can optionally take user input for custom images.\n\n"); + std::cout << desc << std::endl; + return ~0; + } + + bool burn_fpga = (vm.count("no_fpga") == 0); + bool burn_fw = (vm.count("no_fw") == 0); + bool use_custom_fpga = (vm.count("fpga") > 0); + bool use_custom_fw = (vm.count("fw") > 0); + bool list_usrps = (vm.count("list") > 0); + + if(!burn_fpga && !burn_fw){ + std::cout << "No images will be burned." << std::endl; + return ~0; + } + + if(!burn_fw && use_custom_fw) std::cout << boost::format("Conflicting firmware options presented. Will not burn a firmware image.\n\n"); + if(!burn_fpga && use_custom_fpga) std::cout << boost::format("Conflicting FPGA options presented. Will not burn an FPGA image.\n\n"); + + //Variables not from options + boost::uint32_t hw_rev; + bool found_it = false; + boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu]; + const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem); + + //List option + if(list_usrps){ + udp_simple::sptr udp_bc_transport; + usrp2_fw_update_data_t usrp2_ack_pkt = usrp2_fw_update_data_t(); + usrp2_ack_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION); + usrp2_ack_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_OHAI_LOL); + + std::cout << "Available USRP N2XX devices:" << std::endl; + + //Send UDP packets to all broadcast addresses + BOOST_FOREACH(const if_addrs_t &if_addrs, get_if_addrs()){ + //Avoid the loopback device + if(if_addrs.inet == boost::asio::ip::address_v4::loopback().to_string()) continue; + udp_bc_transport = udp_simple::make_broadcast(if_addrs.bcast, BOOST_STRINGIZE(USRP2_UDP_UPDATE_PORT)); + udp_bc_transport->send(boost::asio::buffer(&usrp2_ack_pkt, sizeof(usrp2_ack_pkt))); + + size_t len = udp_bc_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT); + if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_OHAI_OMG){ + usrp2_ack_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_I_CAN_HAS_HW_REV_LOL); + udp_bc_transport->send(boost::asio::buffer(&usrp2_ack_pkt, sizeof(usrp2_ack_pkt))); + + size_t len = udp_bc_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT); + if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_HERES_TEH_HW_REV_OMG){ + hw_rev = ntohl(update_data_in->data.hw_rev); + } + + std::cout << boost::format(" * %s (%s)\n") % udp_bc_transport->get_recv_addr() % filename_map[hw_rev]; + } + + } + return ~0; + } + std::cout << boost::format("Searching for USRP N2XX with IP address %s.\n") % ip_addr; + + //Address specified + udp_simple::sptr udp_transport = udp_simple::make_connected(ip_addr, BOOST_STRINGIZE(USRP2_UDP_UPDATE_PORT)); + usrp2_fw_update_data_t hw_info_pkt = usrp2_fw_update_data_t(); + hw_info_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION); + hw_info_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_I_CAN_HAS_HW_REV_LOL); + udp_transport->send(boost::asio::buffer(&hw_info_pkt, sizeof(hw_info_pkt))); + + //Loop and receive until the timeout + size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT); + if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_HERES_TEH_HW_REV_OMG){ + hw_rev = ntohl(update_data_in->data.hw_rev); + if(filename_map.find(hw_rev) != filename_map.end()){ + std::cout << boost::format("Found %s.\n\n") % filename_map[hw_rev]; + found_it = true; + } + else throw std::runtime_error("Invalid revision found."); + } + if(!found_it) throw std::runtime_error("No USRP N2XX found."); + + //Determining default image filenames for validation + std::string default_fw_filename = str(boost::format("usrp_%s_fw.bin") % erase_tail_copy(filename_map[hw_rev],3)); + std::string default_fpga_filename = str(boost::format("usrp_%s_fpga.bin") % filename_map[hw_rev]); + std::string default_fw_filepath = ""; + std::string default_fpga_filepath = ""; + + //Check validity of file locations and binaries before attempting burn + std::cout << "Searching for specified images." << std::endl << std::endl; + check_image_file_validity(filename_map[hw_rev], default_fpga_filename, default_fw_filename, fpga_path, fw_path, + burn_fpga, burn_fw, use_custom_fpga, use_custom_fw); + if(burn_fw && !use_custom_fw) fw_path = find_image_path(default_fw_filename); + if(burn_fpga && !use_custom_fpga) fpga_path = find_image_path(default_fpga_filename); + check_image_binary_validity(fpga_path, fw_path, burn_fpga, burn_fw); + + std::cout << "Will burn the following images:" << std::endl; + if(burn_fw) std::cout << boost::format(" * Firmware: %s\n") % fw_path; + if(burn_fpga) std::cout << boost::format(" * FPGA: %s\n") % fpga_path; + std::cout << std::endl; + + boost::uint32_t* flash_info = get_flash_info(ip_addr); + std::cout << boost::format("Querying %s for flash information.\n") % filename_map[hw_rev]; + std::cout << boost::format(" * Flash size: %3.2f\n") % flash_info[1]; + std::cout << boost::format(" * Sector size: %3.2f\n\n") % flash_info[0]; + + //Burning images + + if(burn_fpga){ + std::ifstream to_read_fpga((char*)fpga_path.c_str(), std::ios::binary); + to_read_fpga.seekg(0, std::ios::end); + int fpga_image_size = to_read_fpga.tellg(); + to_read_fpga.seekg(0, std::ios::beg); + char fpga_read[FPGA_IMAGE_SIZE_BYTES]; + to_read_fpga.read(fpga_read,fpga_image_size); + to_read_fpga.close(); + boost::uint8_t fpga_image[FPGA_IMAGE_SIZE_BYTES]; + for(int i = 0; i < fpga_image_size; i++) fpga_image[i] = (boost::uint8_t)fpga_read[i]; + + erase_image(udp_transport, false, flash_info[1]); + write_image(udp_transport, false, fpga_image, flash_info[1], fpga_image_size); + verify_image(udp_transport, false, fpga_image, flash_info[1], fpga_image_size); + } + + if(burn_fpga and burn_fw) std::cout << std::endl; //Formatting + + if(burn_fw){ + std::ifstream to_read_fw((char*)fw_path.c_str(), std::ios::binary); + to_read_fw.seekg(0, std::ios::end); + int fw_image_size = to_read_fw.tellg(); + to_read_fw.seekg(0, std::ios::beg); + char fw_read[FW_IMAGE_SIZE_BYTES]; + to_read_fw.read(fw_read,fw_image_size); + to_read_fw.close(); + boost::uint8_t fw_image[FW_IMAGE_SIZE_BYTES]; + for(int i = 0; i < fw_image_size; i++) fw_image[i] = (boost::uint8_t)fw_read[i]; + + erase_image(udp_transport, true, flash_info[1]); + write_image(udp_transport, true, fw_image, flash_info[1], fw_image_size); + verify_image(udp_transport, true, fw_image, flash_info[1], fw_image_size); + } + + //Prompt user to reset USRP + std::string user_response = ""; + bool reset = false; + while(user_response != "yes" and user_response != "no" and user_response != "y" and user_response != "n"){ + std::cout << std::endl << "Image burning successful. Reset USRP (yes/no)? "; + std::getline(std::cin, user_response); + std::transform(user_response.begin(), user_response.end(), user_response.begin(), ::tolower); + reset = (user_response == "yes" or user_response == "y"); + } + std::cout << std::endl; //Formatting + if(reset) reset_usrp(udp_transport); + else return 0; + + return 0; +} diff --git a/host/utils/usrp_simple_burner_utils.hpp b/host/utils/usrp_simple_burner_utils.hpp new file mode 100644 index 000000000..f386c3620 --- /dev/null +++ b/host/utils/usrp_simple_burner_utils.hpp @@ -0,0 +1,99 @@ +// +// Copyright 2012 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 <iostream> +#include <math.h> +#include <stdint.h> + +#include <boost/foreach.hpp> +#include <boost/asio.hpp> +#include <boost/filesystem.hpp> + +#include <uhd/exception.hpp> +#include <uhd/transport/if_addrs.hpp> +#include <uhd/transport/udp_simple.hpp> +#include <uhd/types/device_addr.hpp> +#include <uhd/utils/msg.hpp> + +#define UDP_FW_UPDATE_PORT 49154 +#define UDP_MAX_XFER_BYTES 1024 +#define UDP_TIMEOUT 3 +#define UDP_POLL_INTERVAL 0.10 //in seconds +#define USRP2_FW_PROTO_VERSION 7 //should be unused after r6 +#define USRP2_UDP_UPDATE_PORT 49154 +#define FLASH_DATA_PACKET_SIZE 256 +#define FPGA_IMAGE_SIZE_BYTES 1572864 +#define FW_IMAGE_SIZE_BYTES 31744 +#define PROD_FPGA_IMAGE_LOCATION_ADDR 0x00180000 +#define PROD_FW_IMAGE_LOCATION_ADDR 0x00300000 +#define SAFE_FPGA_IMAGE_LOCATION_ADDR 0x00000000 +#define SAFE_FW_IMAGE_LOCATION_ADDR 0x003F0000 + +using namespace uhd; +using namespace uhd::transport; +namespace asio = boost::asio; + +typedef enum { + USRP2_FW_UPDATE_ID_WAT = ' ', + + USRP2_FW_UPDATE_ID_OHAI_LOL = 'a', + USRP2_FW_UPDATE_ID_OHAI_OMG = 'A', + + USRP2_FW_UPDATE_ID_WATS_TEH_FLASH_INFO_LOL = 'f', + USRP2_FW_UPDATE_ID_HERES_TEH_FLASH_INFO_OMG = 'F', + + USRP2_FW_UPDATE_ID_ERASE_TEH_FLASHES_LOL = 'e', + USRP2_FW_UPDATE_ID_ERASING_TEH_FLASHES_OMG = 'E', + + USRP2_FW_UPDATE_ID_R_U_DONE_ERASING_LOL = 'd', + USRP2_FW_UPDATE_ID_IM_DONE_ERASING_OMG = 'D', + USRP2_FW_UPDATE_ID_NOPE_NOT_DONE_ERASING_OMG = 'B', + + USRP2_FW_UPDATE_ID_WRITE_TEH_FLASHES_LOL = 'w', + USRP2_FW_UPDATE_ID_WROTE_TEH_FLASHES_OMG = 'W', + + USRP2_FW_UPDATE_ID_READ_TEH_FLASHES_LOL = 'r', + USRP2_FW_UPDATE_ID_KK_READ_TEH_FLASHES_OMG = 'R', + + USRP2_FW_UPDATE_ID_RESET_MAH_COMPUTORZ_LOL = 's', + USRP2_FW_UPDATE_ID_RESETTIN_TEH_COMPUTORZ_OMG = 'S', + + USRP2_FW_UPDATE_ID_I_CAN_HAS_HW_REV_LOL = 'v', + USRP2_FW_UPDATE_ID_HERES_TEH_HW_REV_OMG = 'V', + + USRP2_FW_UPDATE_ID_KTHXBAI = '~' + +} usrp2_fw_update_id_t; + +typedef struct { + uint32_t proto_ver; + uint32_t id; + uint32_t seq; + union { + uint32_t ip_addr; + uint32_t hw_rev; + struct { + uint32_t flash_addr; + uint32_t length; + uint8_t data[256]; + } flash_args; + struct { + uint32_t sector_size_bytes; + uint32_t memory_size_bytes; + } flash_info_args; + } data; +} usrp2_fw_update_data_t; |