Remove all boost:: namespace prefix for uint32_t, int32_t etc. (fixed-width types)

- Also removes all references to boost/cstdint.hpp and replaces it with
  stdint.h (The 'correct' replacement would be <cstdint>, but not all of our
  compilers support that).

10 files changed, 167 insertions, 167 deletions

diff --git a/host/lib/usrp/usrp2/clock_ctrl.cpp b/host/lib/usrp/usrp2/clock_ctrl.cpp
index ecb5a7101..c05453c40 100644
--- a/host/lib/usrp/usrp2/clock_ctrl.cpp
+++ b/host/lib/usrp/usrp2/clock_ctrl.cpp
@@ -21,7 +21,7 @@
 #include "usrp2_clk_regs.hpp"
 #include <uhd/utils/safe_call.hpp>
 #include <uhd/utils/assert_has.hpp>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <boost/lexical_cast.hpp>
 #include <boost/math/special_functions/round.hpp>
 #include <iostream>
@@ -334,8 +334,8 @@ private:
      * Write a single register to the spi regs.
      * \param addr the address to write
      */
-    void write_reg(boost::uint8_t addr){
-        boost::uint32_t data = _ad9510_regs.get_write_reg(addr);
+    void write_reg(uint8_t addr){
+        uint32_t data = _ad9510_regs.get_write_reg(addr);
         _spiface->write_spi(SPI_SS_AD9510, spi_config_t::EDGE_RISE, data, 24);
     }
 
diff --git a/host/lib/usrp/usrp2/codec_ctrl.cpp b/host/lib/usrp/usrp2/codec_ctrl.cpp
index a565078cf..a0e456708 100644
--- a/host/lib/usrp/usrp2/codec_ctrl.cpp
+++ b/host/lib/usrp/usrp2/codec_ctrl.cpp
@@ -22,7 +22,7 @@
 #include <uhd/utils/log.hpp>
 #include <uhd/utils/safe_call.hpp>
 #include <uhd/exception.hpp>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <boost/foreach.hpp>
 
 using namespace uhd;
@@ -58,7 +58,7 @@ public:
         _ad9777_regs.qdac_offset_adjust_lsb = 0;
         _ad9777_regs.qdac_offset_adjust_msb = 0;
         //write all regs
-        for(boost::uint8_t addr = 0; addr <= 0xC; addr++){
+        for(uint8_t addr = 0; addr <= 0xC; addr++){
             this->send_ad9777_reg(addr);
         }
         set_tx_mod_mode(0);
@@ -196,8 +196,8 @@ private:
     usrp2_iface::sptr _iface;
     uhd::spi_iface::sptr _spiface;
 
-    void send_ad9777_reg(boost::uint8_t addr){
-        boost::uint16_t reg = _ad9777_regs.get_write_reg(addr);
+    void send_ad9777_reg(uint8_t addr){
+        uint16_t reg = _ad9777_regs.get_write_reg(addr);
         UHD_LOGV(always) << "send_ad9777_reg: " << std::hex << reg << std::endl;
         _spiface->write_spi(
             SPI_SS_AD9777, spi_config_t::EDGE_RISE,
@@ -205,8 +205,8 @@ private:
         );
     }
 
-    void send_ads62p44_reg(boost::uint8_t addr) {
-        boost::uint16_t reg = _ads62p44_regs.get_write_reg(addr);
+    void send_ads62p44_reg(uint8_t addr) {
+        uint16_t reg = _ads62p44_regs.get_write_reg(addr);
         _spiface->write_spi(
             SPI_SS_ADS62P44, spi_config_t::EDGE_FALL,
             reg, 16
diff --git a/host/lib/usrp/usrp2/dboard_iface.cpp b/host/lib/usrp/usrp2/dboard_iface.cpp
index a6ba1e0b7..9fde9a626 100644
--- a/host/lib/usrp/usrp2/dboard_iface.cpp
+++ b/host/lib/usrp/usrp2/dboard_iface.cpp
@@ -54,21 +54,21 @@ public:
     void write_aux_dac(unit_t, aux_dac_t, double);
     double read_aux_adc(unit_t, aux_adc_t);
 
-    void set_pin_ctrl(unit_t unit, boost::uint32_t value, boost::uint32_t mask = 0xffffffff);
-    boost::uint32_t get_pin_ctrl(unit_t unit);
-    void set_atr_reg(unit_t unit, atr_reg_t reg, boost::uint32_t value, boost::uint32_t mask = 0xffffffff);
-    boost::uint32_t get_atr_reg(unit_t unit, atr_reg_t reg);
-    void set_gpio_ddr(unit_t unit, boost::uint32_t value, boost::uint32_t mask = 0xffffffff);
-    boost::uint32_t get_gpio_ddr(unit_t unit);
-    void set_gpio_out(unit_t unit, boost::uint32_t value, boost::uint32_t mask = 0xffffffff);
-    boost::uint32_t get_gpio_out(unit_t unit);
-    boost::uint32_t read_gpio(unit_t unit);
+    void set_pin_ctrl(unit_t unit, uint32_t value, uint32_t mask = 0xffffffff);
+    uint32_t get_pin_ctrl(unit_t unit);
+    void set_atr_reg(unit_t unit, atr_reg_t reg, uint32_t value, uint32_t mask = 0xffffffff);
+    uint32_t get_atr_reg(unit_t unit, atr_reg_t reg);
+    void set_gpio_ddr(unit_t unit, uint32_t value, uint32_t mask = 0xffffffff);
+    uint32_t get_gpio_ddr(unit_t unit);
+    void set_gpio_out(unit_t unit, uint32_t value, uint32_t mask = 0xffffffff);
+    uint32_t get_gpio_out(unit_t unit);
+    uint32_t read_gpio(unit_t unit);
 
     void set_command_time(const uhd::time_spec_t& t);
     uhd::time_spec_t get_command_time(void);
 
-    void write_i2c(boost::uint16_t, const byte_vector_t &);
-    byte_vector_t read_i2c(boost::uint16_t, size_t);
+    void write_i2c(uint16_t, const byte_vector_t &);
+    byte_vector_t read_i2c(uint16_t, size_t);
 
     void set_clock_rate(unit_t, double);
     double get_clock_rate(unit_t);
@@ -80,14 +80,14 @@ public:
     void write_spi(
         unit_t unit,
         const spi_config_t &config,
-        boost::uint32_t data,
+        uint32_t data,
         size_t num_bits
     );
 
-    boost::uint32_t read_write_spi(
+    uint32_t read_write_spi(
         unit_t unit,
         const spi_config_t &config,
-        boost::uint32_t data,
+        uint32_t data,
         size_t num_bits
     );
 
@@ -194,39 +194,39 @@ double usrp2_dboard_iface::get_codec_rate(unit_t unit){
 /***********************************************************************
  * GPIO
  **********************************************************************/
-void usrp2_dboard_iface::set_pin_ctrl(unit_t unit, boost::uint32_t value, boost::uint32_t mask){
-    _gpio->set_pin_ctrl(unit, static_cast<boost::uint16_t>(value), static_cast<boost::uint16_t>(mask));
+void usrp2_dboard_iface::set_pin_ctrl(unit_t unit, uint32_t value, uint32_t mask){
+    _gpio->set_pin_ctrl(unit, static_cast<uint16_t>(value), static_cast<uint16_t>(mask));
 }
 
-boost::uint32_t usrp2_dboard_iface::get_pin_ctrl(unit_t unit){
-    return static_cast<boost::uint32_t>(_gpio->get_pin_ctrl(unit));
+uint32_t usrp2_dboard_iface::get_pin_ctrl(unit_t unit){
+    return static_cast<uint32_t>(_gpio->get_pin_ctrl(unit));
 }
 
-void usrp2_dboard_iface::set_atr_reg(unit_t unit, atr_reg_t reg, boost::uint32_t value, boost::uint32_t mask){
-    _gpio->set_atr_reg(unit, reg, static_cast<boost::uint16_t>(value), static_cast<boost::uint16_t>(mask));
+void usrp2_dboard_iface::set_atr_reg(unit_t unit, atr_reg_t reg, uint32_t value, uint32_t mask){
+    _gpio->set_atr_reg(unit, reg, static_cast<uint16_t>(value), static_cast<uint16_t>(mask));
 }
 
-boost::uint32_t usrp2_dboard_iface::get_atr_reg(unit_t unit, atr_reg_t reg){
-    return static_cast<boost::uint32_t>(_gpio->get_atr_reg(unit, reg));
+uint32_t usrp2_dboard_iface::get_atr_reg(unit_t unit, atr_reg_t reg){
+    return static_cast<uint32_t>(_gpio->get_atr_reg(unit, reg));
 }
 
-void usrp2_dboard_iface::set_gpio_ddr(unit_t unit, boost::uint32_t value, boost::uint32_t mask){
-    _gpio->set_gpio_ddr(unit, static_cast<boost::uint16_t>(value), static_cast<boost::uint16_t>(mask));
+void usrp2_dboard_iface::set_gpio_ddr(unit_t unit, uint32_t value, uint32_t mask){
+    _gpio->set_gpio_ddr(unit, static_cast<uint16_t>(value), static_cast<uint16_t>(mask));
 }
 
-boost::uint32_t usrp2_dboard_iface::get_gpio_ddr(unit_t unit){
-    return static_cast<boost::uint32_t>(_gpio->get_gpio_ddr(unit));
+uint32_t usrp2_dboard_iface::get_gpio_ddr(unit_t unit){
+    return static_cast<uint32_t>(_gpio->get_gpio_ddr(unit));
 }
 
-void usrp2_dboard_iface::set_gpio_out(unit_t unit, boost::uint32_t value, boost::uint32_t mask){
-    _gpio->set_gpio_out(unit, static_cast<boost::uint16_t>(value), static_cast<boost::uint16_t>(mask));
+void usrp2_dboard_iface::set_gpio_out(unit_t unit, uint32_t value, uint32_t mask){
+    _gpio->set_gpio_out(unit, static_cast<uint16_t>(value), static_cast<uint16_t>(mask));
 }
 
-boost::uint32_t usrp2_dboard_iface::get_gpio_out(unit_t unit){
-    return static_cast<boost::uint32_t>(_gpio->get_gpio_out(unit));
+uint32_t usrp2_dboard_iface::get_gpio_out(unit_t unit){
+    return static_cast<uint32_t>(_gpio->get_gpio_out(unit));
 }
 
-boost::uint32_t usrp2_dboard_iface::read_gpio(unit_t unit){
+uint32_t usrp2_dboard_iface::read_gpio(unit_t unit){
     return _gpio->read_gpio(unit);
 }
 
@@ -241,17 +241,17 @@ static const uhd::dict<dboard_iface::unit_t, int> unit_to_spi_dev = map_list_of
 void usrp2_dboard_iface::write_spi(
     unit_t unit,
     const spi_config_t &config,
-    boost::uint32_t data,
+    uint32_t data,
     size_t num_bits
 ){
     if (unit == UNIT_BOTH) throw uhd::runtime_error("UNIT_BOTH not supported.");
     _spi_iface->write_spi(unit_to_spi_dev[unit], config, data, num_bits);
 }
 
-boost::uint32_t usrp2_dboard_iface::read_write_spi(
+uint32_t usrp2_dboard_iface::read_write_spi(
     unit_t unit,
     const spi_config_t &config,
-    boost::uint32_t data,
+    uint32_t data,
     size_t num_bits
 ){
     if (unit == UNIT_BOTH) throw uhd::runtime_error("UNIT_BOTH not supported.");
@@ -261,11 +261,11 @@ boost::uint32_t usrp2_dboard_iface::read_write_spi(
 /***********************************************************************
  * I2C
  **********************************************************************/
-void usrp2_dboard_iface::write_i2c(boost::uint16_t addr, const byte_vector_t &bytes){
+void usrp2_dboard_iface::write_i2c(uint16_t addr, const byte_vector_t &bytes){
     return _i2c_iface->write_i2c(addr, bytes);
 }
 
-byte_vector_t usrp2_dboard_iface::read_i2c(boost::uint16_t addr, size_t num_bytes){
+byte_vector_t usrp2_dboard_iface::read_i2c(uint16_t addr, size_t num_bytes){
     return _i2c_iface->read_i2c(addr, num_bytes);
 }
 
@@ -334,7 +334,7 @@ double usrp2_dboard_iface::read_aux_adc(unit_t unit, aux_adc_t which){
         unit_to_spi_adc[unit], config,
         ad7922_regs.get_reg(), 16
     );
-    ad7922_regs.set_reg(boost::uint16_t(_spi_iface->read_spi(
+    ad7922_regs.set_reg(uint16_t(_spi_iface->read_spi(
         unit_to_spi_adc[unit], config,
         ad7922_regs.get_reg(), 16
     )));
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
index 81be97fa5..ae39028a1 100644
--- a/host/lib/usrp/usrp2/io_impl.cpp
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -66,7 +66,7 @@ static const size_t vrt_send_header_offset_words32 = 1;
  **********************************************************************/
 class flow_control_monitor{
 public:
-    typedef boost::uint32_t seq_type;
+    typedef uint32_t seq_type;
     typedef boost::shared_ptr<flow_control_monitor> sptr;
 
     /*!
@@ -159,7 +159,7 @@ struct usrp2_impl::io_impl{
         managed_send_buffer::sptr buff = tx_xports[chan]->get_send_buff(timeout);
 
         //write the flow control word into the buffer
-        if (buff.get()) buff->cast<boost::uint32_t *>()[0] = uhd::htonx(fc_mon.get_curr_seq_out());
+        if (buff.get()) buff->cast<uint32_t *>()[0] = uhd::htonx(fc_mon.get_curr_seq_out());
 
         return buff;
     }
@@ -196,8 +196,8 @@ void usrp2_impl::io_impl::recv_pirate_loop(
         try{
             //extract the vrt header packet info
             vrt::if_packet_info_t if_packet_info;
-            if_packet_info.num_packet_words32 = buff->size()/sizeof(boost::uint32_t);
-            const boost::uint32_t *vrt_hdr = buff->cast<const boost::uint32_t *>();
+            if_packet_info.num_packet_words32 = buff->size()/sizeof(uint32_t);
+            const uint32_t *vrt_hdr = buff->cast<const uint32_t *>();
             vrt::if_hdr_unpack_be(vrt_hdr, if_packet_info);
 
             //handle a tx async report message
@@ -205,11 +205,11 @@ void usrp2_impl::io_impl::recv_pirate_loop(
 
                 //fill in the async metadata
                 async_metadata_t metadata;
-                load_metadata_from_buff(uhd::ntohx<boost::uint32_t>, metadata, if_packet_info, vrt_hdr, tick_rate, index);
+                load_metadata_from_buff(uhd::ntohx<uint32_t>, metadata, if_packet_info, vrt_hdr, tick_rate, index);
 
                 //catch the flow control packets and react
                 if (metadata.event_code == 0){
-                    boost::uint32_t fc_word32 = (vrt_hdr + if_packet_info.num_header_words32)[1];
+                    uint32_t fc_word32 = (vrt_hdr + if_packet_info.num_header_words32)[1];
                     fc_mon.update_fc_condition(uhd::ntohx(fc_word32));
                     continue;
                 }
@@ -374,8 +374,8 @@ void usrp2_impl::program_stream_dest(
 
     //program the stream command
     usrp2_stream_ctrl_t stream_ctrl = usrp2_stream_ctrl_t();
-    stream_ctrl.sequence = uhd::htonx(boost::uint32_t(0 /* don't care seq num */));
-    stream_ctrl.vrt_hdr = uhd::htonx(boost::uint32_t(USRP2_INVALID_VRT_HEADER));
+    stream_ctrl.sequence = uhd::htonx(uint32_t(0 /* don't care seq num */));
+    stream_ctrl.vrt_hdr = uhd::htonx(uint32_t(USRP2_INVALID_VRT_HEADER));
 
     //user has provided an alternative address and port for destination
     if (args.args.has_key("addr") and args.args.has_key("port")){
@@ -388,8 +388,8 @@ void usrp2_impl::program_stream_dest(
         asio::ip::udp::resolver resolver(io_service);
         asio::ip::udp::resolver::query query(asio::ip::udp::v4(), args.args["addr"], args.args["port"]);
         asio::ip::udp::endpoint endpoint = *resolver.resolve(query);
-        stream_ctrl.ip_addr = uhd::htonx(boost::uint32_t(endpoint.address().to_v4().to_ulong()));
-        stream_ctrl.udp_port = uhd::htonx(boost::uint32_t(endpoint.port()));
+        stream_ctrl.ip_addr = uhd::htonx(uint32_t(endpoint.address().to_v4().to_ulong()));
+        stream_ctrl.udp_port = uhd::htonx(uint32_t(endpoint.port()));
 
         for (size_t i = 0; i < 3; i++){
             UHD_MSG(status) << "ARP attempt " << i << std::endl;
@@ -399,8 +399,8 @@ void usrp2_impl::program_stream_dest(
             send_buff.reset();
             boost::this_thread::sleep(boost::posix_time::milliseconds(300));
             managed_recv_buffer::sptr recv_buff = xport->get_recv_buff(0.0);
-            if (recv_buff and recv_buff->size() >= sizeof(boost::uint32_t)){
-                const boost::uint32_t result = uhd::ntohx(recv_buff->cast<const boost::uint32_t *>()[0]);
+            if (recv_buff and recv_buff->size() >= sizeof(uint32_t)){
+                const uint32_t result = uhd::ntohx(recv_buff->cast<const uint32_t *>()[0]);
                 if (result == 0){
                     UHD_MSG(status) << "Success! " << std::endl;
                     return;
@@ -430,7 +430,7 @@ rx_streamer::sptr usrp2_impl::get_rx_stream(const uhd::stream_args_t &args_){
 
     //calculate packet size
     static const size_t hdr_size = 0
-        + vrt::max_if_hdr_words32*sizeof(boost::uint32_t)
+        + vrt::max_if_hdr_words32*sizeof(uint32_t)
         + sizeof(vrt::if_packet_info_t().tlr) //forced to have trailer
         - sizeof(vrt::if_packet_info_t().cid) //no class id ever used
         - sizeof(vrt::if_packet_info_t().tsi) //no int time ever used
@@ -498,8 +498,8 @@ tx_streamer::sptr usrp2_impl::get_tx_stream(const uhd::stream_args_t &args_){
 
     //calculate packet size
     static const size_t hdr_size = 0
-        + vrt_send_header_offset_words32*sizeof(boost::uint32_t)
-        + vrt::max_if_hdr_words32*sizeof(boost::uint32_t)
+        + vrt_send_header_offset_words32*sizeof(uint32_t)
+        + vrt::max_if_hdr_words32*sizeof(uint32_t)
         + sizeof(vrt::if_packet_info_t().tlr) //forced to have trailer
         - sizeof(vrt::if_packet_info_t().cid) //no class id ever used
         - sizeof(vrt::if_packet_info_t().sid) //no stream id ever used
diff --git a/host/lib/usrp/usrp2/n200_image_loader.cpp b/host/lib/usrp/usrp2/n200_image_loader.cpp
index d6acfe39d..16cc7b08a 100644
--- a/host/lib/usrp/usrp2/n200_image_loader.cpp
+++ b/host/lib/usrp/usrp2/n200_image_loader.cpp
@@ -100,7 +100,7 @@ typedef enum {
 /*
  * Mapping revision numbers to names
  */
-static const uhd::dict<boost::uint32_t, std::string> n200_filename_map = boost::assign::map_list_of
+static const uhd::dict<uint32_t, std::string> n200_filename_map = boost::assign::map_list_of
     (0,      "n2xx")    // Is an N-Series, but the EEPROM value is invalid
     (0xa,    "n200_r3")
     (0x100a, "n200_r4")
@@ -112,20 +112,20 @@ static const uhd::dict<boost::uint32_t, std::string> n200_filename_map = boost::
  * Packet structure
  */
 typedef struct {
-    boost::uint32_t proto_ver;
-    boost::uint32_t id;
-    boost::uint32_t seq;
+    uint32_t proto_ver;
+    uint32_t id;
+    uint32_t seq;
     union {
-        boost::uint32_t ip_addr;
-        boost::uint32_t hw_rev;
+        uint32_t ip_addr;
+        uint32_t hw_rev;
         struct {
-            boost::uint32_t flash_addr;
-            boost::uint32_t length;
-            boost::uint8_t  data[256];
+            uint32_t flash_addr;
+            uint32_t length;
+            uint8_t  data[256];
         } flash_args;
         struct {
-            boost::uint32_t sector_size_bytes;
-            boost::uint32_t memory_size_bytes;
+            uint32_t sector_size_bytes;
+            uint32_t memory_size_bytes;
         } flash_info_args;
     } data;
 } n200_fw_update_data_t;
@@ -140,10 +140,10 @@ typedef struct {
     uhd::device_addr_t dev_addr;
     std::string        burn_type;
     std::string        filepath;
-    boost::uint8_t     data_in[udp_simple::mtu];
-    boost::uint32_t    size;
-    boost::uint32_t    max_size;
-    boost::uint32_t    flash_addr;
+    uint8_t     data_in[udp_simple::mtu];
+    uint32_t    size;
+    uint32_t    max_size;
+    uint32_t    flash_addr;
     udp_simple::sptr   xport;
 } n200_session_t;
 
@@ -190,9 +190,9 @@ static void print_usrp2_error(const image_loader::image_loader_args_t &image_loa
 static UHD_INLINE size_t n200_send_and_recv(udp_simple::sptr xport,
                                             n200_fw_update_id_t pkt_code,
                                             n200_fw_update_data_t *pkt_out,
-                                            boost::uint8_t* data){
-    pkt_out->proto_ver = htonx<boost::uint32_t>(USRP2_FW_COMPAT_NUM);
-    pkt_out->id = htonx<boost::uint32_t>(pkt_code);
+                                            uint8_t* data){
+    pkt_out->proto_ver = htonx<uint32_t>(USRP2_FW_COMPAT_NUM);
+    pkt_out->id = htonx<uint32_t>(pkt_code);
     xport->send(boost::asio::buffer(pkt_out, sizeof(*pkt_out)));
     return xport->recv(boost::asio::buffer(data, udp_simple::mtu), UDP_TIMEOUT);
 }
@@ -215,7 +215,7 @@ static uhd::device_addr_t n200_find(const image_loader::image_loader_args_t &ima
         uhd::device_addrs_t n200_found;
         udp_simple::sptr rev_xport;
         n200_fw_update_data_t pkt_out;
-        boost::uint8_t data_in[udp_simple::mtu];
+        uint8_t data_in[udp_simple::mtu];
         const n200_fw_update_data_t *pkt_in = reinterpret_cast<const n200_fw_update_data_t*>(data_in);
         size_t len = 0;
 
@@ -233,7 +233,7 @@ static uhd::device_addr_t n200_find(const image_loader::image_loader_args_t &ima
 
             len = n200_send_and_recv(rev_xport, GET_HW_REV_CMD, &pkt_out, data_in);
             if(n200_response_matches(pkt_in, GET_HW_REV_ACK, len)){
-                boost::uint32_t rev = ntohl(pkt_in->data.hw_rev);
+                uint32_t rev = ntohl(pkt_in->data.hw_rev);
                 std::string hw_rev = n200_filename_map.get(rev, "n2xx");
 
                 n200_found.push_back(dev);
@@ -291,7 +291,7 @@ static void n200_validate_firmware_image(n200_session_t &session){
 
     // File must have proper header
     std::ifstream image_file(session.filepath.c_str(), std::ios::binary);
-    boost::uint8_t test_bytes[4];
+    uint8_t test_bytes[4];
     image_file.seekg(0, std::ios::beg);
     image_file.read((char*)test_bytes,4);
     image_file.close();
@@ -320,7 +320,7 @@ static void n200_validate_fpga_image(n200_session_t &session){
 
     // File must have proper header
     std::ifstream image_file(session.filepath.c_str(), std::ios::binary);
-    boost::uint8_t test_bytes[63];
+    uint8_t test_bytes[63];
     image_file.seekg(0, std::ios::beg);
     image_file.read((char*)test_bytes, 63);
     bool is_good = false;
@@ -402,8 +402,8 @@ static void n200_erase_image(n200_session_t &session){
     const n200_fw_update_data_t *pkt_in = reinterpret_cast<const n200_fw_update_data_t*>(session.data_in);
 
     // Setting up UDP packet
-    pkt_out.data.flash_args.flash_addr = htonx<boost::uint32_t>(session.flash_addr);
-    pkt_out.data.flash_args.length = htonx<boost::uint32_t>(session.size);
+    pkt_out.data.flash_args.flash_addr = htonx<uint32_t>(session.flash_addr);
+    pkt_out.data.flash_args.length = htonx<uint32_t>(session.size);
 
     // Begin erasing
     size_t len = n200_send_and_recv(session.xport, ERASE_FLASH_CMD, &pkt_out, session.data_in);
@@ -452,10 +452,10 @@ static void n200_write_image(n200_session_t &session){
 
     // Write image
     std::ifstream image(session.filepath.c_str(), std::ios::binary);
-    boost::uint32_t current_addr = session.flash_addr;
-    pkt_out.data.flash_args.length = htonx<boost::uint32_t>(N200_FLASH_DATA_PACKET_SIZE);
+    uint32_t current_addr = session.flash_addr;
+    pkt_out.data.flash_args.length = htonx<uint32_t>(N200_FLASH_DATA_PACKET_SIZE);
     for(size_t i = 0; i < ((session.size/N200_FLASH_DATA_PACKET_SIZE)+1); i++){
-        pkt_out.data.flash_args.flash_addr = htonx<boost::uint32_t>(current_addr);
+        pkt_out.data.flash_args.flash_addr = htonx<uint32_t>(current_addr);
         memset(pkt_out.data.flash_args.data, 0x0, N200_FLASH_DATA_PACKET_SIZE);
         image.read((char*)pkt_out.data.flash_args.data, N200_FLASH_DATA_PACKET_SIZE);
 
@@ -502,15 +502,15 @@ static void n200_verify_image(n200_session_t &session){
 
     // Read and verify image
     std::ifstream image(session.filepath.c_str(), std::ios::binary);
-    boost::uint8_t image_part[N200_FLASH_DATA_PACKET_SIZE];
-    boost::uint32_t current_addr = session.flash_addr;
-    pkt_out.data.flash_args.length = htonx<boost::uint32_t>(N200_FLASH_DATA_PACKET_SIZE);
-    boost::uint16_t cmp_len = 0;
+    uint8_t image_part[N200_FLASH_DATA_PACKET_SIZE];
+    uint32_t current_addr = session.flash_addr;
+    pkt_out.data.flash_args.length = htonx<uint32_t>(N200_FLASH_DATA_PACKET_SIZE);
+    uint16_t cmp_len = 0;
     for(size_t i = 0; i < ((session.size/N200_FLASH_DATA_PACKET_SIZE)+1); i++){
         memset(image_part, 0x0, N200_FLASH_DATA_PACKET_SIZE);
         memset((void*)pkt_in->data.flash_args.data, 0x0, N200_FLASH_DATA_PACKET_SIZE);
 
-        pkt_out.data.flash_args.flash_addr = htonx<boost::uint32_t>(current_addr);
+        pkt_out.data.flash_args.flash_addr = htonx<uint32_t>(current_addr);
         image.read((char*)image_part, N200_FLASH_DATA_PACKET_SIZE);
         cmp_len = image.gcount();
 
diff --git a/host/lib/usrp/usrp2/usrp2_fifo_ctrl.cpp b/host/lib/usrp/usrp2/usrp2_fifo_ctrl.cpp
index e0544862d..9cd3afc6c 100644
--- a/host/lib/usrp/usrp2/usrp2_fifo_ctrl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_fifo_ctrl.cpp
@@ -33,7 +33,7 @@ static const size_t POKE32_CMD = (1 << 8);
 static const size_t PEEK32_CMD = 0;
 static const double ACK_TIMEOUT = 0.5;
 static const double MASSIVE_TIMEOUT = 10.0; //for when we wait on a timed command
-static const boost::uint32_t MAX_SEQS_OUT = 63;
+static const uint32_t MAX_SEQS_OUT = 63;
 
 #define SPI_DIV SR_SPI_CORE + 0
 #define SPI_CTRL SR_SPI_CORE + 1
@@ -67,7 +67,7 @@ public:
     /*******************************************************************
      * Peek and poke 32 bit implementation
      ******************************************************************/
-    void poke32(const wb_addr_type addr, const boost::uint32_t data){
+    void poke32(const wb_addr_type addr, const uint32_t data){
         boost::mutex::scoped_lock lock(_mutex);
 
         this->send_pkt((addr - SETTING_REGS_BASE)/4, data, POKE32_CMD);
@@ -75,7 +75,7 @@ public:
         this->wait_for_ack(_seq_out-MAX_SEQS_OUT);
     }
 
-    boost::uint32_t peek32(const wb_addr_type addr){
+    uint32_t peek32(const wb_addr_type addr){
         boost::mutex::scoped_lock lock(_mutex);
 
         this->send_pkt((addr - READBACK_BASE)/4, 0, PEEK32_CMD);
@@ -86,11 +86,11 @@ public:
     /*******************************************************************
      * Peek and poke 16 bit not implemented
      ******************************************************************/
-    void poke16(const wb_addr_type, const boost::uint16_t){
+    void poke16(const wb_addr_type, const uint16_t){
         throw uhd::not_implemented_error("poke16 not implemented in fifo ctrl module");
     }
 
-    boost::uint16_t peek16(const wb_addr_type){
+    uint16_t peek16(const wb_addr_type){
         throw uhd::not_implemented_error("peek16 not implemented in fifo ctrl module");
     }
 
@@ -106,24 +106,24 @@ public:
         _ctrl_word_cache = 0; // force update first time around
     }
 
-    boost::uint32_t transact_spi(
+    uint32_t transact_spi(
         int which_slave,
         const spi_config_t &config,
-        boost::uint32_t data,
+        uint32_t data,
         size_t num_bits,
         bool readback
     ){
         boost::mutex::scoped_lock lock(_mutex);
 
         //load control word
-        boost::uint32_t ctrl_word = 0;
+        uint32_t ctrl_word = 0;
         ctrl_word |= ((which_slave & 0xffffff) << 0);
         ctrl_word |= ((num_bits & 0x3ff) << 24);
         if (config.mosi_edge == spi_config_t::EDGE_FALL) ctrl_word |= (1 << 31);
         if (config.miso_edge == spi_config_t::EDGE_RISE) ctrl_word |= (1 << 30);
 
         //load data word (must be in upper bits)
-        const boost::uint32_t data_out = data << (32 - num_bits);
+        const uint32_t data_out = data << (32 - num_bits);
 
         //conditionally send control word
         if (_ctrl_word_cache != ctrl_word){
@@ -171,20 +171,20 @@ private:
     /*******************************************************************
      * Primary control and interaction private methods
      ******************************************************************/
-    UHD_INLINE void send_pkt(wb_addr_type addr, boost::uint32_t data, int cmd){
+    UHD_INLINE void send_pkt(wb_addr_type addr, uint32_t data, int cmd){
         managed_send_buffer::sptr buff = _xport->get_send_buff(0.0);
         if (not buff){
             throw uhd::runtime_error("fifo ctrl timed out getting a send buffer");
         }
-        boost::uint32_t *trans = buff->cast<boost::uint32_t *>();
+        uint32_t *trans = buff->cast<uint32_t *>();
         trans[0] = htonl(++_seq_out);
-        boost::uint32_t *pkt = trans + 1;
+        uint32_t *pkt = trans + 1;
 
         //load packet info
         vrt::if_packet_info_t packet_info;
         packet_info.packet_type = vrt::if_packet_info_t::PACKET_TYPE_CONTEXT;
         packet_info.num_payload_words32 = 2;
-        packet_info.num_payload_bytes = packet_info.num_payload_words32*sizeof(boost::uint32_t);
+        packet_info.num_payload_bytes = packet_info.num_payload_words32*sizeof(uint32_t);
         packet_info.packet_count = _seq_out;
         packet_info.tsf = _time.to_ticks(_tick_rate);
         packet_info.sob = false;
@@ -199,30 +199,30 @@ private:
         vrt::if_hdr_pack_be(pkt, packet_info);
 
         //load payload
-        const boost::uint32_t ctrl_word = (addr & 0xff) | cmd | (_seq_out << 16);
+        const uint32_t ctrl_word = (addr & 0xff) | cmd | (_seq_out << 16);
         pkt[packet_info.num_header_words32+0] = htonl(ctrl_word);
         pkt[packet_info.num_header_words32+1] = htonl(data);
 
         //send the buffer over the interface
-        buff->commit(sizeof(boost::uint32_t)*(packet_info.num_packet_words32+1));
+        buff->commit(sizeof(uint32_t)*(packet_info.num_packet_words32+1));
     }
 
-    UHD_INLINE bool wraparound_lt16(const boost::int16_t i0, const boost::int16_t i1){
+    UHD_INLINE bool wraparound_lt16(const int16_t i0, const int16_t i1){
         if (((i0 ^ i1) & 0x8000) == 0) //same sign bits
-            return boost::uint16_t(i0) < boost::uint16_t(i1);
-        return boost::int16_t(i1 - i0) > 0;
+            return uint16_t(i0) < uint16_t(i1);
+        return int16_t(i1 - i0) > 0;
     }
 
-    UHD_INLINE boost::uint32_t wait_for_ack(const boost::uint16_t seq_to_ack){
+    UHD_INLINE uint32_t wait_for_ack(const uint16_t seq_to_ack){
 
         while (wraparound_lt16(_seq_ack, seq_to_ack)){
             managed_recv_buffer::sptr buff = _xport->get_recv_buff(_timeout);
             if (not buff){
                 throw uhd::runtime_error("fifo ctrl timed out looking for acks");
             }
-            const boost::uint32_t *pkt = buff->cast<const boost::uint32_t *>();
+            const uint32_t *pkt = buff->cast<const uint32_t *>();
             vrt::if_packet_info_t packet_info;
-            packet_info.num_packet_words32 = buff->size()/sizeof(boost::uint32_t);
+            packet_info.num_packet_words32 = buff->size()/sizeof(uint32_t);
             vrt::if_hdr_unpack_be(pkt, packet_info);
             _seq_ack = ntohl(pkt[packet_info.num_header_words32+0]) >> 16;
             if (_seq_ack == seq_to_ack){
@@ -235,13 +235,13 @@ private:
 
     zero_copy_if::sptr _xport;
     boost::mutex _mutex;
-    boost::uint16_t _seq_out;
-    boost::uint16_t _seq_ack;
+    uint16_t _seq_out;
+    uint16_t _seq_ack;
     uhd::time_spec_t _time;
     bool _use_time;
     double _tick_rate;
     double _timeout;
-    boost::uint32_t _ctrl_word_cache;
+    uint32_t _ctrl_word_cache;
 };
 
 
diff --git a/host/lib/usrp/usrp2/usrp2_iface.cpp b/host/lib/usrp/usrp2/usrp2_iface.cpp
index 2b382ae38..522d6c6d0 100644
--- a/host/lib/usrp/usrp2/usrp2_iface.cpp
+++ b/host/lib/usrp/usrp2/usrp2_iface.cpp
@@ -57,12 +57,12 @@ struct timeout_error : uhd::runtime_error
     }
 };
 
-static const boost::uint32_t MIN_PROTO_COMPAT_SPI = 7;
-static const boost::uint32_t MIN_PROTO_COMPAT_I2C = 7;
+static const uint32_t MIN_PROTO_COMPAT_SPI = 7;
+static const 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 = 10;
-static const boost::uint32_t MIN_PROTO_COMPAT_UART = 7;
+static const uint32_t MIN_PROTO_COMPAT_REG = 10;
+static const uint32_t MIN_PROTO_COMPAT_UART = 7;
 
 class usrp2_iface_impl : public usrp2_iface{
 public:
@@ -110,15 +110,15 @@ public:
         //never assume lock with fpga image mismatch
         if ((this->peek32(U2_REG_COMPAT_NUM_RB) >> 16) != USRP2_FPGA_COMPAT_NUM) return false;
 
-        boost::uint32_t lock_time = this->peekfw(U2_FW_REG_LOCK_TIME);
-        boost::uint32_t lock_gpid = this->peekfw(U2_FW_REG_LOCK_GPID);
+        uint32_t lock_time = this->peekfw(U2_FW_REG_LOCK_TIME);
+        uint32_t lock_gpid = this->peekfw(U2_FW_REG_LOCK_GPID);
 
         //may not be the right tick rate, but this is ok for locking purposes
-        const boost::uint32_t lock_timeout_time = boost::uint32_t(3*100e6);
+        const uint32_t lock_timeout_time = uint32_t(3*100e6);
 
         //if the difference is larger, assume not locked anymore
         if ((lock_time & 1) == 0) return false; //bit0 says unlocked
-        const boost::uint32_t time_diff = this->get_curr_time() - lock_time;
+        const uint32_t time_diff = this->get_curr_time() - lock_time;
         if (time_diff >= lock_timeout_time) return false;
 
         //otherwise only lock if the device hash is different that ours
@@ -132,37 +132,37 @@ public:
         boost::this_thread::sleep(boost::posix_time::milliseconds(1500));
     }
 
-    boost::uint32_t get_curr_time(void){
+    uint32_t get_curr_time(void){
         return this->peek32(U2_REG_TIME64_LO_RB_IMM) | 1; //bit 1 says locked
     }
 
 /***********************************************************************
  * Peek and Poke
  **********************************************************************/
-    void poke32(const wb_addr_type addr, const boost::uint32_t data){
-        this->get_reg<boost::uint32_t, USRP2_REG_ACTION_FPGA_POKE32>(addr, data);
+    void poke32(const wb_addr_type addr, const uint32_t data){
+        this->get_reg<uint32_t, USRP2_REG_ACTION_FPGA_POKE32>(addr, data);
     }
 
-    boost::uint32_t peek32(const wb_addr_type addr){
-        return this->get_reg<boost::uint32_t, USRP2_REG_ACTION_FPGA_PEEK32>(addr);
+    uint32_t peek32(const wb_addr_type addr){
+        return this->get_reg<uint32_t, USRP2_REG_ACTION_FPGA_PEEK32>(addr);
     }
 
-    void poke16(const wb_addr_type addr, const boost::uint16_t data){
-        this->get_reg<boost::uint16_t, USRP2_REG_ACTION_FPGA_POKE16>(addr, data);
+    void poke16(const wb_addr_type addr, const uint16_t data){
+        this->get_reg<uint16_t, USRP2_REG_ACTION_FPGA_POKE16>(addr, data);
     }
 
-    boost::uint16_t peek16(const wb_addr_type addr){
-        return this->get_reg<boost::uint16_t, USRP2_REG_ACTION_FPGA_PEEK16>(addr);
+    uint16_t peek16(const wb_addr_type addr){
+        return this->get_reg<uint16_t, USRP2_REG_ACTION_FPGA_PEEK16>(addr);
     }
 
-    void pokefw(wb_addr_type addr, boost::uint32_t data)
+    void pokefw(wb_addr_type addr, uint32_t data)
     {
-        this->get_reg<boost::uint32_t, USRP2_REG_ACTION_FW_POKE32>(addr, data);
+        this->get_reg<uint32_t, USRP2_REG_ACTION_FW_POKE32>(addr, data);
     }
 
-    boost::uint32_t peekfw(wb_addr_type addr)
+    uint32_t peekfw(wb_addr_type addr)
     {
-        return this->get_reg<boost::uint32_t, USRP2_REG_ACTION_FW_PEEK32>(addr);
+        return this->get_reg<uint32_t, USRP2_REG_ACTION_FW_PEEK32>(addr);
     }
 
     template <class T, usrp2_reg_action_t action>
@@ -171,7 +171,7 @@ public:
         usrp2_ctrl_data_t out_data = usrp2_ctrl_data_t();
         out_data.id = htonl(USRP2_CTRL_ID_GET_THIS_REGISTER_FOR_ME_BRO);
         out_data.data.reg_args.addr = htonl(addr);
-        out_data.data.reg_args.data = htonl(boost::uint32_t(data));
+        out_data.data.reg_args.data = htonl(uint32_t(data));
         out_data.data.reg_args.action = action;
 
         //send and recv
@@ -183,10 +183,10 @@ public:
 /***********************************************************************
  * SPI
  **********************************************************************/
-    boost::uint32_t transact_spi(
+    uint32_t transact_spi(
         int which_slave,
         const spi_config_t &config,
-        boost::uint32_t data,
+        uint32_t data,
         size_t num_bits,
         bool readback
     ){
@@ -215,7 +215,7 @@ public:
 /***********************************************************************
  * I2C
  **********************************************************************/
-    void write_i2c(boost::uint16_t addr, const byte_vector_t &buf){
+    void write_i2c(uint16_t addr, const byte_vector_t &buf){
         //setup the out data
         usrp2_ctrl_data_t out_data = usrp2_ctrl_data_t();
         out_data.id = htonl(USRP2_CTRL_ID_WRITE_THESE_I2C_VALUES_BRO);
@@ -233,7 +233,7 @@ public:
         UHD_ASSERT_THROW(ntohl(in_data.id) == USRP2_CTRL_ID_COOL_IM_DONE_I2C_WRITE_DUDE);
     }
 
-    byte_vector_t read_i2c(boost::uint16_t addr, size_t num_bytes){
+    byte_vector_t read_i2c(uint16_t addr, size_t num_bytes){
         //setup the out data
         usrp2_ctrl_data_t out_data = usrp2_ctrl_data_t();
         out_data.id = htonl(USRP2_CTRL_ID_DO_AN_I2C_READ_FOR_ME_BRO);
@@ -259,8 +259,8 @@ public:
  **********************************************************************/
     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
+        uint32_t lo = USRP2_FW_COMPAT_NUM,
+        uint32_t hi = USRP2_FW_COMPAT_NUM
     ){
         boost::mutex::scoped_lock lock(_ctrl_mutex);
 
@@ -280,7 +280,7 @@ public:
 
     usrp2_ctrl_data_t ctrl_send_and_recv_internal(
         const usrp2_ctrl_data_t &out_data,
-        boost::uint32_t lo, boost::uint32_t hi,
+        uint32_t lo, uint32_t hi,
         const double timeout
     ){
         //fill in the seq number and send
@@ -290,12 +290,12 @@ public:
         _ctrl_transport->send(boost::asio::buffer(&out_copy, sizeof(usrp2_ctrl_data_t)));
 
         //loop until we get the packet or timeout
-        boost::uint8_t usrp2_ctrl_data_in_mem[udp_simple::mtu]; //allocate max bytes for recv
+        uint8_t usrp2_ctrl_data_in_mem[udp_simple::mtu]; //allocate max bytes for recv
         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), timeout);
-            boost::uint32_t compat = ntohl(ctrl_data_in->proto_ver);
-            if(len >= sizeof(boost::uint32_t) and (hi < compat or lo > compat)){
+            uint32_t compat = ntohl(ctrl_data_in->proto_ver);
+            if(len >= sizeof(uint32_t) and (hi < compat or lo > compat)){
                 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"
@@ -317,7 +317,7 @@ public:
     rev_type get_rev(void){
         std::string hw = mb_eeprom["hardware"];
         if (hw.empty()) return USRP_NXXX;
-        switch (boost::lexical_cast<boost::uint16_t>(hw)){
+        switch (boost::lexical_cast<uint16_t>(hw)){
         case 0x0300:
         case 0x0301: return USRP2_REV3;
         case 0x0400: return USRP2_REV4;
@@ -343,7 +343,7 @@ public:
     }
 
     const std::string get_fw_version_string(void){
-        boost::uint32_t minor = this->get_reg<boost::uint32_t, USRP2_REG_ACTION_FW_PEEK32>(U2_FW_REG_VER_MINOR);
+        uint32_t minor = this->get_reg<uint32_t, USRP2_REG_ACTION_FW_PEEK32>(U2_FW_REG_VER_MINOR);
         return str(boost::format("%u.%u") % _protocol_compat % minor);
     }
 
@@ -415,8 +415,8 @@ private:
 
     //used in send/recv
     boost::mutex _ctrl_mutex;
-    boost::uint32_t _ctrl_seq_num;
-    boost::uint32_t _protocol_compat;
+    uint32_t _ctrl_seq_num;
+    uint32_t _protocol_compat;
 
     //lock thread stuff
     task::sptr _lock_task;
diff --git a/host/lib/usrp/usrp2/usrp2_iface.hpp b/host/lib/usrp/usrp2/usrp2_iface.hpp
index 833016b7c..9d7642bc1 100644
--- a/host/lib/usrp/usrp2/usrp2_iface.hpp
+++ b/host/lib/usrp/usrp2/usrp2_iface.hpp
@@ -45,10 +45,10 @@ public:
     static sptr make(uhd::transport::udp_simple::sptr ctrl_transport);
 
     //! poke a register in the virtual fw table
-    virtual void pokefw(wb_addr_type addr, boost::uint32_t data) = 0;
+    virtual void pokefw(wb_addr_type addr, uint32_t data) = 0;
 
     //! peek a register in the virtual fw table
-    virtual boost::uint32_t peekfw(wb_addr_type addr) = 0;
+    virtual uint32_t peekfw(wb_addr_type addr) = 0;
 
     //! The list of possible revision types
     enum rev_type {
diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp
index b0c29392c..ee2434fab 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.cpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.cpp
@@ -112,8 +112,8 @@ device_addrs_t usrp2_find(const device_addr_t &hint_){
 
     //send a hello control packet
     usrp2_ctrl_data_t ctrl_data_out = usrp2_ctrl_data_t();
-    ctrl_data_out.proto_ver = uhd::htonx<boost::uint32_t>(USRP2_FW_COMPAT_NUM);
-    ctrl_data_out.id = uhd::htonx<boost::uint32_t>(USRP2_CTRL_ID_WAZZUP_BRO);
+    ctrl_data_out.proto_ver = uhd::htonx<uint32_t>(USRP2_FW_COMPAT_NUM);
+    ctrl_data_out.id = uhd::htonx<uint32_t>(USRP2_CTRL_ID_WAZZUP_BRO);
     try
     {
         udp_transport->send(boost::asio::buffer(&ctrl_data_out, sizeof(ctrl_data_out)));
@@ -128,7 +128,7 @@ device_addrs_t usrp2_find(const device_addr_t &hint_){
     }
 
     //loop and recieve until the timeout
-    boost::uint8_t usrp2_ctrl_data_in_mem[udp_simple::mtu]; //allocate max bytes for recv
+    uint8_t usrp2_ctrl_data_in_mem[udp_simple::mtu]; //allocate max bytes for recv
     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 = udp_transport->recv(asio::buffer(usrp2_ctrl_data_in_mem));
@@ -218,7 +218,7 @@ static mtu_result_t determine_mtu(const std::string &addr, const mtu_result_t &u
     //The FPGA offers 4K buffers, and the user may manually request this.
     //However, multiple simultaneous receives (2DSP slave + 2DSP master),
     //require that buffering to be used internally, and this is a safe setting.
-    std::vector<boost::uint8_t> buffer(std::max(user_mtu.recv_mtu, user_mtu.send_mtu));
+    std::vector<uint8_t> buffer(std::max(user_mtu.recv_mtu, user_mtu.send_mtu));
     usrp2_ctrl_data_t *ctrl_data = reinterpret_cast<usrp2_ctrl_data_t *>(&buffer.front());
     static const double echo_timeout = 0.020; //20 ms
 
@@ -302,9 +302,9 @@ static zero_copy_if::sptr make_xport(
     //Send a small data packet so the usrp2 knows the udp source port.
     //This setup must happen before further initialization occurs
     //or the async update packets will cause ICMP destination unreachable.
-    static const boost::uint32_t data[2] = {
-        uhd::htonx(boost::uint32_t(0 /* don't care seq num */)),
-        uhd::htonx(boost::uint32_t(USRP2_INVALID_VRT_HEADER))
+    static const uint32_t data[2] = {
+        uhd::htonx(uint32_t(0 /* don't care seq num */)),
+        uhd::htonx(uint32_t(USRP2_INVALID_VRT_HEADER))
     };
     transport::managed_send_buffer::sptr send_buff = xport->get_send_buff();
     std::memcpy(send_buff->cast<void*>(), &data, sizeof(data));
@@ -389,8 +389,8 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr) :
         _tree->create<std::string>(mb_path / "fw_version").set(_mbc[mb].iface->get_fw_version_string());
 
         //check the fpga compatibility number
-        const boost::uint32_t fpga_compat_num = _mbc[mb].iface->peek32(U2_REG_COMPAT_NUM_RB);
-        boost::uint16_t fpga_major = fpga_compat_num >> 16, fpga_minor = fpga_compat_num & 0xffff;
+        const uint32_t fpga_compat_num = _mbc[mb].iface->peek32(U2_REG_COMPAT_NUM_RB);
+        uint16_t fpga_major = fpga_compat_num >> 16, fpga_minor = fpga_compat_num & 0xffff;
         if (fpga_major == 0){ //old version scheme
             fpga_major = fpga_minor;
             fpga_minor = 0;
@@ -520,7 +520,7 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr) :
         ////////////////////////////////////////////////////////////////////
         // Create the GPSDO control
         ////////////////////////////////////////////////////////////////////
-        static const boost::uint32_t dont_look_for_gpsdo = 0x1234abcdul;
+        static const uint32_t dont_look_for_gpsdo = 0x1234abcdul;
 
         //disable check for internal GPSDO when not the following:
         switch(_mbc[mb].iface->get_rev()){
diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp
index 47fcec657..790daa749 100644
--- a/host/lib/usrp/usrp2/usrp2_impl.hpp
+++ b/host/lib/usrp/usrp2/usrp2_impl.hpp
@@ -52,8 +52,8 @@ static const double mimo_clock_delay_usrp2_rev4 = 4.18e-9;
 static const double mimo_clock_delay_usrp_n2xx = 4.10e-9;
 static const size_t mimo_clock_sync_delay_cycles = 138;
 static const size_t USRP2_SRAM_BYTES = size_t(1 << 20);
-static const boost::uint32_t USRP2_TX_ASYNC_SID = 2;
-static const boost::uint32_t USRP2_RX_SID_BASE = 3;
+static const uint32_t USRP2_TX_ASYNC_SID = 2;
+static const uint32_t USRP2_RX_SID_BASE = 3;
 static const std::string USRP2_EEPROM_MAP_KEY = "N100";
 
 uhd::device_addrs_t usrp2_find(const uhd::device_addr_t &hint_);