usrp-e100: renamed files and classes in usrp-e100 to e100 name

18 files changed, 218 insertions, 218 deletions

diff --git a/host/lib/usrp/usrp_e100/CMakeLists.txt b/host/lib/usrp/usrp_e100/CMakeLists.txt
index 17ef53152..97a3d5d9a 100644
--- a/host/lib/usrp/usrp_e100/CMakeLists.txt
+++ b/host/lib/usrp/usrp_e100/CMakeLists.txt
@@ -52,12 +52,12 @@ IF(ENABLE_USRP_E100)
         ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/fpga-downloader.cc
         ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/io_impl.cpp
         ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/mboard_impl.cpp
-        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e_impl.cpp
-        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e_impl.hpp
-        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e_iface.cpp
-        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e_iface.hpp
-        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e_mmap_zero_copy.cpp
-        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e_regs.hpp
+        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e100_impl.cpp
+        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e100_impl.hpp
+        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e100_iface.cpp
+        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e100_iface.hpp
+        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e100_mmap_zero_copy.cpp
+        ${CMAKE_SOURCE_DIR}/lib/usrp/usrp_e100/usrp_e100_regs.hpp
     )
 ELSE(ENABLE_USRP_E100)
     MESSAGE(STATUS "  Skipping USRP-E100 support.")
diff --git a/host/lib/usrp/usrp_e100/clock_ctrl.cpp b/host/lib/usrp/usrp_e100/clock_ctrl.cpp
index 9d4625305..e99560540 100644
--- a/host/lib/usrp/usrp_e100/clock_ctrl.cpp
+++ b/host/lib/usrp/usrp_e100/clock_ctrl.cpp
@@ -19,7 +19,7 @@
 #include "ad9522_regs.hpp"
 #include <uhd/utils/assert.hpp>
 #include <boost/cstdint.hpp>
-#include "usrp_e_regs.hpp" //spi slave constants
+#include "usrp_e100_regs.hpp" //spi slave constants
 #include <boost/assign/list_of.hpp>
 #include <boost/foreach.hpp>
 #include <utility>
@@ -58,9 +58,9 @@ static const size_t codec_clock_divider = size_t(master_clock_rate/64e6);
 /***********************************************************************
  * Clock Control Implementation
  **********************************************************************/
-class usrp_e_clock_ctrl_impl : public usrp_e_clock_ctrl{
+class usrp_e100_clock_ctrl_impl : public usrp_e100_clock_ctrl{
 public:
-    usrp_e_clock_ctrl_impl(usrp_e_iface::sptr iface){
+    usrp_e100_clock_ctrl_impl(usrp_e100_iface::sptr iface){
         _iface = iface;
 
         //init the clock gen registers
@@ -137,7 +137,7 @@ public:
         this->enable_tx_dboard_clock(false);
     }
 
-    ~usrp_e_clock_ctrl_impl(void){
+    ~usrp_e100_clock_ctrl_impl(void){
         this->enable_rx_dboard_clock(false);
         this->enable_tx_dboard_clock(false);
     }
@@ -210,7 +210,7 @@ public:
     }
 
 private:
-    usrp_e_iface::sptr _iface;
+    usrp_e100_iface::sptr _iface;
     ad9522_regs_t _ad9522_regs;
 
     void latch_regs(void){
@@ -232,6 +232,6 @@ private:
 /***********************************************************************
  * Clock Control Make
  **********************************************************************/
-usrp_e_clock_ctrl::sptr usrp_e_clock_ctrl::make(usrp_e_iface::sptr iface){
-    return sptr(new usrp_e_clock_ctrl_impl(iface));
+usrp_e100_clock_ctrl::sptr usrp_e100_clock_ctrl::make(usrp_e100_iface::sptr iface){
+    return sptr(new usrp_e100_clock_ctrl_impl(iface));
 }
diff --git a/host/lib/usrp/usrp_e100/clock_ctrl.hpp b/host/lib/usrp/usrp_e100/clock_ctrl.hpp
index 3b5103ed1..0ae68728e 100644
--- a/host/lib/usrp/usrp_e100/clock_ctrl.hpp
+++ b/host/lib/usrp/usrp_e100/clock_ctrl.hpp
@@ -15,10 +15,10 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#ifndef INCLUDED_USRP_E_CLOCK_CTRL_HPP
-#define INCLUDED_USRP_E_CLOCK_CTRL_HPP
+#ifndef INCLUDED_USRP_E100_CLOCK_CTRL_HPP
+#define INCLUDED_USRP_E100_CLOCK_CTRL_HPP
 
-#include "usrp_e_iface.hpp"
+#include "usrp_e100_iface.hpp"
 #include <boost/shared_ptr.hpp>
 #include <boost/utility.hpp>
 #include <vector>
@@ -28,16 +28,16 @@
  * - Setup system clocks.
  * - Disable/enable clock lines.
  */
-class usrp_e_clock_ctrl : boost::noncopyable{
+class usrp_e100_clock_ctrl : boost::noncopyable{
 public:
-    typedef boost::shared_ptr<usrp_e_clock_ctrl> sptr;
+    typedef boost::shared_ptr<usrp_e100_clock_ctrl> sptr;
 
     /*!
      * Make a new clock control object.
-     * \param iface the usrp_e iface object
+     * \param iface the usrp_e100 iface object
      * \return the clock control object
      */
-    static sptr make(usrp_e_iface::sptr iface);
+    static sptr make(usrp_e100_iface::sptr iface);
 
     /*!
      * Get the rate of the fpga clock line.
@@ -85,4 +85,4 @@ public:
 
 };
 
-#endif /* INCLUDED_USRP_E_CLOCK_CTRL_HPP */
+#endif /* INCLUDED_USRP_E100_CLOCK_CTRL_HPP */
diff --git a/host/lib/usrp/usrp_e100/codec_ctrl.cpp b/host/lib/usrp/usrp_e100/codec_ctrl.cpp
index a728d7e46..e7fd9792e 100644
--- a/host/lib/usrp/usrp_e100/codec_ctrl.cpp
+++ b/host/lib/usrp/usrp_e100/codec_ctrl.cpp
@@ -23,7 +23,7 @@
 #include <boost/cstdint.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/math/special_functions/round.hpp>
-#include "usrp_e_regs.hpp" //spi slave constants
+#include "usrp_e100_regs.hpp" //spi slave constants
 #include <boost/assign/list_of.hpp>
 #include <iostream>
 
@@ -31,17 +31,17 @@ using namespace uhd;
 
 static const bool codec_debug = false;
 
-const gain_range_t usrp_e_codec_ctrl::tx_pga_gain_range(-20, 0, float(0.1));
-const gain_range_t usrp_e_codec_ctrl::rx_pga_gain_range(0, 20, 1);
+const gain_range_t usrp_e100_codec_ctrl::tx_pga_gain_range(-20, 0, float(0.1));
+const gain_range_t usrp_e100_codec_ctrl::rx_pga_gain_range(0, 20, 1);
 
 /***********************************************************************
  * Codec Control Implementation
  **********************************************************************/
-class usrp_e_codec_ctrl_impl : public usrp_e_codec_ctrl{
+class usrp_e100_codec_ctrl_impl : public usrp_e100_codec_ctrl{
 public:
     //structors
-    usrp_e_codec_ctrl_impl(usrp_e_iface::sptr iface);
-    ~usrp_e_codec_ctrl_impl(void);
+    usrp_e100_codec_ctrl_impl(usrp_e100_iface::sptr iface);
+    ~usrp_e100_codec_ctrl_impl(void);
 
     //aux adc and dac control
     float read_aux_adc(aux_adc_t which);
@@ -54,7 +54,7 @@ public:
     float get_rx_pga_gain(char);
 
 private:
-    usrp_e_iface::sptr _iface;
+    usrp_e100_iface::sptr _iface;
     ad9862_regs_t _ad9862_regs;
     aux_adc_t _last_aux_adc_a, _last_aux_adc_b;
     void send_reg(boost::uint8_t addr);
@@ -64,7 +64,7 @@ private:
 /***********************************************************************
  * Codec Control Structors
  **********************************************************************/
-usrp_e_codec_ctrl_impl::usrp_e_codec_ctrl_impl(usrp_e_iface::sptr iface){
+usrp_e100_codec_ctrl_impl::usrp_e100_codec_ctrl_impl(usrp_e100_iface::sptr iface){
     _iface = iface;
 
     //soft reset
@@ -115,7 +115,7 @@ usrp_e_codec_ctrl_impl::usrp_e_codec_ctrl_impl(usrp_e_iface::sptr iface){
     this->send_reg(34);
 }
 
-usrp_e_codec_ctrl_impl::~usrp_e_codec_ctrl_impl(void){
+usrp_e100_codec_ctrl_impl::~usrp_e100_codec_ctrl_impl(void){
     //set aux dacs to zero
     this->write_aux_dac(AUX_DAC_A, 0);
     this->write_aux_dac(AUX_DAC_B, 0);
@@ -135,19 +135,19 @@ usrp_e_codec_ctrl_impl::~usrp_e_codec_ctrl_impl(void){
  **********************************************************************/
 static const int mtpgw = 255; //maximum tx pga gain word
 
-void usrp_e_codec_ctrl_impl::set_tx_pga_gain(float gain){
+void usrp_e100_codec_ctrl_impl::set_tx_pga_gain(float gain){
     int gain_word = int(mtpgw*(gain - tx_pga_gain_range.min)/(tx_pga_gain_range.max - tx_pga_gain_range.min));
     _ad9862_regs.tx_pga_gain = std::clip(gain_word, 0, mtpgw);
     this->send_reg(16);
 }
 
-float usrp_e_codec_ctrl_impl::get_tx_pga_gain(void){
+float usrp_e100_codec_ctrl_impl::get_tx_pga_gain(void){
     return (_ad9862_regs.tx_pga_gain*(tx_pga_gain_range.max - tx_pga_gain_range.min)/mtpgw) + tx_pga_gain_range.min;
 }
 
 static const int mrpgw = 0x14; //maximum rx pga gain word
 
-void usrp_e_codec_ctrl_impl::set_rx_pga_gain(float gain, char which){
+void usrp_e100_codec_ctrl_impl::set_rx_pga_gain(float gain, char which){
     int gain_word = int(mrpgw*(gain - rx_pga_gain_range.min)/(rx_pga_gain_range.max - rx_pga_gain_range.min));
     gain_word = std::clip(gain_word, 0, mrpgw);
     switch(which){
@@ -163,7 +163,7 @@ void usrp_e_codec_ctrl_impl::set_rx_pga_gain(float gain, char which){
     }
 }
 
-float usrp_e_codec_ctrl_impl::get_rx_pga_gain(char which){
+float usrp_e100_codec_ctrl_impl::get_rx_pga_gain(char which){
     int gain_word;
     switch(which){
     case 'A': gain_word = _ad9862_regs.rx_pga_a; break;
@@ -180,7 +180,7 @@ static float aux_adc_to_volts(boost::uint8_t high, boost::uint8_t low){
     return float((boost::uint16_t(high) << 2) | low)*3.3/0x3ff;
 }
 
-float usrp_e_codec_ctrl_impl::read_aux_adc(aux_adc_t which){
+float usrp_e100_codec_ctrl_impl::read_aux_adc(aux_adc_t which){
     //check to see if the switch needs to be set
     bool write_switch = false;
     switch(which){
@@ -233,7 +233,7 @@ float usrp_e_codec_ctrl_impl::read_aux_adc(aux_adc_t which){
 /***********************************************************************
  * Codec Control AUX DAC Methods
  **********************************************************************/
-void usrp_e_codec_ctrl_impl::write_aux_dac(aux_dac_t which, float volts){
+void usrp_e100_codec_ctrl_impl::write_aux_dac(aux_dac_t which, float volts){
     //special case for aux dac d (aka sigma delta word)
     if (which == AUX_DAC_D){
         boost::uint16_t dac_word = std::clip(boost::math::iround(volts*0xfff/3.3), 0, 0xfff);
@@ -266,7 +266,7 @@ void usrp_e_codec_ctrl_impl::write_aux_dac(aux_dac_t which, float volts){
 /***********************************************************************
  * Codec Control SPI Methods
  **********************************************************************/
-void usrp_e_codec_ctrl_impl::send_reg(boost::uint8_t addr){
+void usrp_e100_codec_ctrl_impl::send_reg(boost::uint8_t addr){
     boost::uint32_t reg = _ad9862_regs.get_write_reg(addr);
     if (codec_debug) std::cout << "codec control write reg: " << std::hex << reg << std::endl;
     _iface->transact_spi(
@@ -276,7 +276,7 @@ void usrp_e_codec_ctrl_impl::send_reg(boost::uint8_t addr){
     );
 }
 
-void usrp_e_codec_ctrl_impl::recv_reg(boost::uint8_t addr){
+void usrp_e100_codec_ctrl_impl::recv_reg(boost::uint8_t addr){
     boost::uint32_t reg = _ad9862_regs.get_read_reg(addr);
     if (codec_debug) std::cout << "codec control read reg: " << std::hex << reg << std::endl;
     boost::uint32_t ret = _iface->transact_spi(
@@ -291,6 +291,6 @@ void usrp_e_codec_ctrl_impl::recv_reg(boost::uint8_t addr){
 /***********************************************************************
  * Codec Control Make
  **********************************************************************/
-usrp_e_codec_ctrl::sptr usrp_e_codec_ctrl::make(usrp_e_iface::sptr iface){
-    return sptr(new usrp_e_codec_ctrl_impl(iface));
+usrp_e100_codec_ctrl::sptr usrp_e100_codec_ctrl::make(usrp_e100_iface::sptr iface){
+    return sptr(new usrp_e100_codec_ctrl_impl(iface));
 }
diff --git a/host/lib/usrp/usrp_e100/codec_ctrl.hpp b/host/lib/usrp/usrp_e100/codec_ctrl.hpp
index 87b6ff951..74ce9bd9a 100644
--- a/host/lib/usrp/usrp_e100/codec_ctrl.hpp
+++ b/host/lib/usrp/usrp_e100/codec_ctrl.hpp
@@ -15,10 +15,10 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#ifndef INCLUDED_USRP_E_CODEC_CTRL_HPP
-#define INCLUDED_USRP_E_CODEC_CTRL_HPP
+#ifndef INCLUDED_USRP_E100_CODEC_CTRL_HPP
+#define INCLUDED_USRP_E100_CODEC_CTRL_HPP
 
-#include "usrp_e_iface.hpp"
+#include "usrp_e100_iface.hpp"
 #include <uhd/types/ranges.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/utility.hpp>
@@ -28,19 +28,19 @@
  * - Init/power down codec.
  * - Read aux adc, write aux dac.
  */
-class usrp_e_codec_ctrl : boost::noncopyable{
+class usrp_e100_codec_ctrl : boost::noncopyable{
 public:
-    typedef boost::shared_ptr<usrp_e_codec_ctrl> sptr;
+    typedef boost::shared_ptr<usrp_e100_codec_ctrl> sptr;
 
     static const uhd::gain_range_t tx_pga_gain_range;
     static const uhd::gain_range_t rx_pga_gain_range;
 
     /*!
      * Make a new codec control object.
-     * \param iface the usrp_e iface object
+     * \param iface the usrp_e100 iface object
      * \return the codec control object
      */
-    static sptr make(usrp_e_iface::sptr iface);
+    static sptr make(usrp_e100_iface::sptr iface);
 
     //! aux adc identifier constants
     enum aux_adc_t{
@@ -87,4 +87,4 @@ public:
     virtual float get_rx_pga_gain(char which) = 0;
 };
 
-#endif /* INCLUDED_USRP_E_CODEC_CTRL_HPP */
+#endif /* INCLUDED_USRP_E100_CODEC_CTRL_HPP */
diff --git a/host/lib/usrp/usrp_e100/codec_impl.cpp b/host/lib/usrp/usrp_e100/codec_impl.cpp
index 696fb37ec..6fd44bad3 100644
--- a/host/lib/usrp/usrp_e100/codec_impl.cpp
+++ b/host/lib/usrp/usrp_e100/codec_impl.cpp
@@ -15,7 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_impl.hpp"
+#include "usrp_e100_impl.hpp"
 #include <uhd/utils/assert.hpp>
 #include <uhd/usrp/codec_props.hpp>
 #include <boost/bind.hpp>
@@ -26,15 +26,15 @@ using namespace uhd::usrp;
 /***********************************************************************
  * Helper Methods
  **********************************************************************/
-void usrp_e_impl::codec_init(void){
+void usrp_e100_impl::codec_init(void){
     //make proxies
     _rx_codec_proxy = wax_obj_proxy::make(
-        boost::bind(&usrp_e_impl::rx_codec_get, this, _1, _2),
-        boost::bind(&usrp_e_impl::rx_codec_set, this, _1, _2)
+        boost::bind(&usrp_e100_impl::rx_codec_get, this, _1, _2),
+        boost::bind(&usrp_e100_impl::rx_codec_set, this, _1, _2)
     );
     _tx_codec_proxy = wax_obj_proxy::make(
-        boost::bind(&usrp_e_impl::tx_codec_get, this, _1, _2),
-        boost::bind(&usrp_e_impl::tx_codec_set, this, _1, _2)
+        boost::bind(&usrp_e100_impl::tx_codec_get, this, _1, _2),
+        boost::bind(&usrp_e100_impl::tx_codec_set, this, _1, _2)
     );
 }
 
@@ -43,7 +43,7 @@ void usrp_e_impl::codec_init(void){
  **********************************************************************/
 static const std::string ad9862_pga_gain_name = "ad9862 pga";
 
-void usrp_e_impl::rx_codec_get(const wax::obj &key_, wax::obj &val){
+void usrp_e100_impl::rx_codec_get(const wax::obj &key_, wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     //handle the get request conditioned on the key
@@ -62,7 +62,7 @@ void usrp_e_impl::rx_codec_get(const wax::obj &key_, wax::obj &val){
 
     case CODEC_PROP_GAIN_RANGE:
         UHD_ASSERT_THROW(key.name == ad9862_pga_gain_name);
-        val = usrp_e_codec_ctrl::rx_pga_gain_range;
+        val = usrp_e100_codec_ctrl::rx_pga_gain_range;
         return;
 
     case CODEC_PROP_GAIN_I:
@@ -79,7 +79,7 @@ void usrp_e_impl::rx_codec_get(const wax::obj &key_, wax::obj &val){
     }
 }
 
-void usrp_e_impl::rx_codec_set(const wax::obj &key_, const wax::obj &val){
+void usrp_e100_impl::rx_codec_set(const wax::obj &key_, const wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     //handle the set request conditioned on the key
@@ -101,7 +101,7 @@ void usrp_e_impl::rx_codec_set(const wax::obj &key_, const wax::obj &val){
 /***********************************************************************
  * TX Codec Properties
  **********************************************************************/
-void usrp_e_impl::tx_codec_get(const wax::obj &key_, wax::obj &val){
+void usrp_e100_impl::tx_codec_get(const wax::obj &key_, wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     //handle the get request conditioned on the key
@@ -120,7 +120,7 @@ void usrp_e_impl::tx_codec_get(const wax::obj &key_, wax::obj &val){
 
     case CODEC_PROP_GAIN_RANGE:
         UHD_ASSERT_THROW(key.name == ad9862_pga_gain_name);
-        val = usrp_e_codec_ctrl::tx_pga_gain_range;
+        val = usrp_e100_codec_ctrl::tx_pga_gain_range;
         return;
 
     case CODEC_PROP_GAIN_I: //only one gain for I and Q
@@ -133,7 +133,7 @@ void usrp_e_impl::tx_codec_get(const wax::obj &key_, wax::obj &val){
     }
 }
 
-void usrp_e_impl::tx_codec_set(const wax::obj &key_, const wax::obj &val){
+void usrp_e100_impl::tx_codec_set(const wax::obj &key_, const wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     //handle the set request conditioned on the key
diff --git a/host/lib/usrp/usrp_e100/dboard_iface.cpp b/host/lib/usrp/usrp_e100/dboard_iface.cpp
index 6898df8df..aa96171d6 100644
--- a/host/lib/usrp/usrp_e100/dboard_iface.cpp
+++ b/host/lib/usrp/usrp_e100/dboard_iface.cpp
@@ -15,8 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_iface.hpp"
-#include "usrp_e_regs.hpp"
+#include "usrp_e100_iface.hpp"
+#include "usrp_e100_regs.hpp"
 #include "clock_ctrl.hpp"
 #include "codec_ctrl.hpp"
 #include <uhd/usrp/dboard_iface.hpp>
@@ -29,13 +29,13 @@ using namespace uhd;
 using namespace uhd::usrp;
 using namespace boost::assign;
 
-class usrp_e_dboard_iface : public dboard_iface{
+class usrp_e100_dboard_iface : public dboard_iface{
 public:
 
-    usrp_e_dboard_iface(
-        usrp_e_iface::sptr iface,
-        usrp_e_clock_ctrl::sptr clock,
-        usrp_e_codec_ctrl::sptr codec
+    usrp_e100_dboard_iface(
+        usrp_e100_iface::sptr iface,
+        usrp_e100_clock_ctrl::sptr clock,
+        usrp_e100_codec_ctrl::sptr codec
     ){
         _iface = iface;
         _clock = clock;
@@ -49,7 +49,7 @@ public:
         _iface->poke16(UE_REG_GPIO_TX_DBG, 0);
     }
 
-    ~usrp_e_dboard_iface(void){
+    ~usrp_e100_dboard_iface(void){
         /* NOP */
     }
 
@@ -94,27 +94,27 @@ public:
     double get_codec_rate(unit_t);
 
 private:
-    usrp_e_iface::sptr _iface;
-    usrp_e_clock_ctrl::sptr _clock;
-    usrp_e_codec_ctrl::sptr _codec;
+    usrp_e100_iface::sptr _iface;
+    usrp_e100_clock_ctrl::sptr _clock;
+    usrp_e100_codec_ctrl::sptr _codec;
     uhd::dict<unit_t, double> _clock_rates;
 };
 
 /***********************************************************************
  * Make Function
  **********************************************************************/
-dboard_iface::sptr make_usrp_e_dboard_iface(
-    usrp_e_iface::sptr iface,
-    usrp_e_clock_ctrl::sptr clock,
-    usrp_e_codec_ctrl::sptr codec
+dboard_iface::sptr make_usrp_e100_dboard_iface(
+    usrp_e100_iface::sptr iface,
+    usrp_e100_clock_ctrl::sptr clock,
+    usrp_e100_codec_ctrl::sptr codec
 ){
-    return dboard_iface::sptr(new usrp_e_dboard_iface(iface, clock, codec));
+    return dboard_iface::sptr(new usrp_e100_dboard_iface(iface, clock, codec));
 }
 
 /***********************************************************************
  * Clock Rates
  **********************************************************************/
-void usrp_e_dboard_iface::set_clock_rate(unit_t unit, double rate){
+void usrp_e100_dboard_iface::set_clock_rate(unit_t unit, double rate){
     _clock_rates[unit] = rate;
     switch(unit){
     case UNIT_RX: return _clock->set_rx_dboard_clock_rate(rate);
@@ -122,7 +122,7 @@ void usrp_e_dboard_iface::set_clock_rate(unit_t unit, double rate){
     }
 }
 
-std::vector<double> usrp_e_dboard_iface::get_clock_rates(unit_t unit){
+std::vector<double> usrp_e100_dboard_iface::get_clock_rates(unit_t unit){
     switch(unit){
     case UNIT_RX: return _clock->get_rx_dboard_clock_rates();
     case UNIT_TX: return _clock->get_tx_dboard_clock_rates();
@@ -130,25 +130,25 @@ std::vector<double> usrp_e_dboard_iface::get_clock_rates(unit_t unit){
     }
 }
 
-double usrp_e_dboard_iface::get_clock_rate(unit_t unit){
+double usrp_e100_dboard_iface::get_clock_rate(unit_t unit){
     return _clock_rates[unit];
 }
 
-void usrp_e_dboard_iface::set_clock_enabled(unit_t unit, bool enb){
+void usrp_e100_dboard_iface::set_clock_enabled(unit_t unit, bool enb){
     switch(unit){
     case UNIT_RX: return _clock->enable_rx_dboard_clock(enb);
     case UNIT_TX: return _clock->enable_tx_dboard_clock(enb);
     }
 }
 
-double usrp_e_dboard_iface::get_codec_rate(unit_t){
+double usrp_e100_dboard_iface::get_codec_rate(unit_t){
     return _clock->get_fpga_clock_rate();
 }
 
 /***********************************************************************
  * GPIO
  **********************************************************************/
-void usrp_e_dboard_iface::set_pin_ctrl(unit_t unit, boost::uint16_t value){
+void usrp_e100_dboard_iface::set_pin_ctrl(unit_t unit, boost::uint16_t value){
     UHD_ASSERT_THROW(GPIO_SEL_ATR == 1); //make this assumption
     switch(unit){
     case UNIT_RX: _iface->poke16(UE_REG_GPIO_RX_SEL, value); return;
@@ -156,21 +156,21 @@ void usrp_e_dboard_iface::set_pin_ctrl(unit_t unit, boost::uint16_t value){
     }
 }
 
-void usrp_e_dboard_iface::set_gpio_ddr(unit_t unit, boost::uint16_t value){
+void usrp_e100_dboard_iface::set_gpio_ddr(unit_t unit, boost::uint16_t value){
     switch(unit){
     case UNIT_RX: _iface->poke16(UE_REG_GPIO_RX_DDR, value); return;
     case UNIT_TX: _iface->poke16(UE_REG_GPIO_TX_DDR, value); return;
     }
 }
 
-void usrp_e_dboard_iface::write_gpio(unit_t unit, boost::uint16_t value){
+void usrp_e100_dboard_iface::write_gpio(unit_t unit, boost::uint16_t value){
     switch(unit){
     case UNIT_RX: _iface->poke16(UE_REG_GPIO_RX_IO, value); return;
     case UNIT_TX: _iface->poke16(UE_REG_GPIO_TX_IO, value); return;
     }
 }
 
-boost::uint16_t usrp_e_dboard_iface::read_gpio(unit_t unit){
+boost::uint16_t usrp_e100_dboard_iface::read_gpio(unit_t unit){
     switch(unit){
     case UNIT_RX: return _iface->peek16(UE_REG_GPIO_RX_IO);
     case UNIT_TX: return _iface->peek16(UE_REG_GPIO_TX_IO);
@@ -178,7 +178,7 @@ boost::uint16_t usrp_e_dboard_iface::read_gpio(unit_t unit){
     }
 }
 
-void usrp_e_dboard_iface::set_atr_reg(unit_t unit, atr_reg_t atr, boost::uint16_t value){
+void usrp_e100_dboard_iface::set_atr_reg(unit_t unit, atr_reg_t atr, boost::uint16_t value){
     //define mapping of unit to atr regs to register address
     static const uhd::dict<
         unit_t, uhd::dict<atr_reg_t, boost::uint32_t>
@@ -199,7 +199,7 @@ void usrp_e_dboard_iface::set_atr_reg(unit_t unit, atr_reg_t atr, boost::uint16_
     _iface->poke16(unit_to_atr_to_addr[unit][atr], value);
 }
 
-void usrp_e_dboard_iface::set_gpio_debug(unit_t unit, int which){
+void usrp_e100_dboard_iface::set_gpio_debug(unit_t unit, int which){
     //set this unit to all outputs
     this->set_gpio_ddr(unit, 0xffff);
 
@@ -238,7 +238,7 @@ static boost::uint32_t unit_to_otw_spi_dev(dboard_iface::unit_t unit){
     throw std::invalid_argument("unknown unit type");
 }
 
-void usrp_e_dboard_iface::write_spi(
+void usrp_e100_dboard_iface::write_spi(
     unit_t unit,
     const spi_config_t &config,
     boost::uint32_t data,
@@ -247,7 +247,7 @@ void usrp_e_dboard_iface::write_spi(
     _iface->transact_spi(unit_to_otw_spi_dev(unit), config, data, num_bits, false /*no rb*/);
 }
 
-boost::uint32_t usrp_e_dboard_iface::read_write_spi(
+boost::uint32_t usrp_e100_dboard_iface::read_write_spi(
     unit_t unit,
     const spi_config_t &config,
     boost::uint32_t data,
@@ -259,39 +259,39 @@ boost::uint32_t usrp_e_dboard_iface::read_write_spi(
 /***********************************************************************
  * I2C
  **********************************************************************/
-void usrp_e_dboard_iface::write_i2c(boost::uint8_t addr, const byte_vector_t &bytes){
+void usrp_e100_dboard_iface::write_i2c(boost::uint8_t addr, const byte_vector_t &bytes){
     return _iface->write_i2c(addr, bytes);
 }
 
-byte_vector_t usrp_e_dboard_iface::read_i2c(boost::uint8_t addr, size_t num_bytes){
+byte_vector_t usrp_e100_dboard_iface::read_i2c(boost::uint8_t addr, size_t num_bytes){
     return _iface->read_i2c(addr, num_bytes);
 }
 
 /***********************************************************************
  * Aux DAX/ADC
  **********************************************************************/
-void usrp_e_dboard_iface::write_aux_dac(dboard_iface::unit_t, aux_dac_t which, float value){
+void usrp_e100_dboard_iface::write_aux_dac(dboard_iface::unit_t, aux_dac_t which, float value){
     //same aux dacs for each unit
-    static const uhd::dict<aux_dac_t, usrp_e_codec_ctrl::aux_dac_t> which_to_aux_dac = map_list_of
-        (AUX_DAC_A, usrp_e_codec_ctrl::AUX_DAC_A)
-        (AUX_DAC_B, usrp_e_codec_ctrl::AUX_DAC_B)
-        (AUX_DAC_C, usrp_e_codec_ctrl::AUX_DAC_C)
-        (AUX_DAC_D, usrp_e_codec_ctrl::AUX_DAC_D)
+    static const uhd::dict<aux_dac_t, usrp_e100_codec_ctrl::aux_dac_t> which_to_aux_dac = map_list_of
+        (AUX_DAC_A, usrp_e100_codec_ctrl::AUX_DAC_A)
+        (AUX_DAC_B, usrp_e100_codec_ctrl::AUX_DAC_B)
+        (AUX_DAC_C, usrp_e100_codec_ctrl::AUX_DAC_C)
+        (AUX_DAC_D, usrp_e100_codec_ctrl::AUX_DAC_D)
     ;
     _codec->write_aux_dac(which_to_aux_dac[which], value);
 }
 
-float usrp_e_dboard_iface::read_aux_adc(dboard_iface::unit_t unit, aux_adc_t which){
+float usrp_e100_dboard_iface::read_aux_adc(dboard_iface::unit_t unit, aux_adc_t which){
     static const uhd::dict<
-        unit_t, uhd::dict<aux_adc_t, usrp_e_codec_ctrl::aux_adc_t>
+        unit_t, uhd::dict<aux_adc_t, usrp_e100_codec_ctrl::aux_adc_t>
     > unit_to_which_to_aux_adc = map_list_of
         (UNIT_RX, map_list_of
-            (AUX_ADC_A, usrp_e_codec_ctrl::AUX_ADC_A1)
-            (AUX_ADC_B, usrp_e_codec_ctrl::AUX_ADC_B1)
+            (AUX_ADC_A, usrp_e100_codec_ctrl::AUX_ADC_A1)
+            (AUX_ADC_B, usrp_e100_codec_ctrl::AUX_ADC_B1)
         )
         (UNIT_TX, map_list_of
-            (AUX_ADC_A, usrp_e_codec_ctrl::AUX_ADC_A2)
-            (AUX_ADC_B, usrp_e_codec_ctrl::AUX_ADC_B2)
+            (AUX_ADC_A, usrp_e100_codec_ctrl::AUX_ADC_A2)
+            (AUX_ADC_B, usrp_e100_codec_ctrl::AUX_ADC_B2)
         )
     ;
     return _codec->read_aux_adc(unit_to_which_to_aux_adc[unit][which]);
diff --git a/host/lib/usrp/usrp_e100/dboard_impl.cpp b/host/lib/usrp/usrp_e100/dboard_impl.cpp
index f2840dcfc..9f2bfb8ae 100644
--- a/host/lib/usrp/usrp_e100/dboard_impl.cpp
+++ b/host/lib/usrp/usrp_e100/dboard_impl.cpp
@@ -15,8 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_impl.hpp"
-#include "usrp_e_regs.hpp"
+#include "usrp_e100_impl.hpp"
+#include "usrp_e100_regs.hpp"
 #include <uhd/utils/assert.hpp>
 #include <uhd/usrp/dboard_props.hpp>
 #include <uhd/usrp/subdev_props.hpp>
@@ -30,12 +30,12 @@ using namespace uhd::usrp;
 /***********************************************************************
  * Dboard Initialization
  **********************************************************************/
-void usrp_e_impl::dboard_init(void){
+void usrp_e100_impl::dboard_init(void){
     _rx_db_eeprom = dboard_eeprom_t(_iface->read_eeprom(I2C_ADDR_RX_DB, 0, dboard_eeprom_t::num_bytes()));
     _tx_db_eeprom = dboard_eeprom_t(_iface->read_eeprom(I2C_ADDR_TX_DB, 0, dboard_eeprom_t::num_bytes()));
 
     //create a new dboard interface and manager
-    _dboard_iface = make_usrp_e_dboard_iface(
+    _dboard_iface = make_usrp_e100_dboard_iface(
         _iface, _clock_ctrl, _codec_ctrl
     );
     _dboard_manager = dboard_manager::make(
@@ -44,19 +44,19 @@ void usrp_e_impl::dboard_init(void){
 
     //setup the dboard proxies
     _rx_dboard_proxy = wax_obj_proxy::make(
-        boost::bind(&usrp_e_impl::rx_dboard_get, this, _1, _2),
-        boost::bind(&usrp_e_impl::rx_dboard_set, this, _1, _2)
+        boost::bind(&usrp_e100_impl::rx_dboard_get, this, _1, _2),
+        boost::bind(&usrp_e100_impl::rx_dboard_set, this, _1, _2)
     );
     _tx_dboard_proxy = wax_obj_proxy::make(
-        boost::bind(&usrp_e_impl::tx_dboard_get, this, _1, _2),
-        boost::bind(&usrp_e_impl::tx_dboard_set, this, _1, _2)
+        boost::bind(&usrp_e100_impl::tx_dboard_get, this, _1, _2),
+        boost::bind(&usrp_e100_impl::tx_dboard_set, this, _1, _2)
     );
 }
 
 /***********************************************************************
  * RX Dboard Get
  **********************************************************************/
-void usrp_e_impl::rx_dboard_get(const wax::obj &key_, wax::obj &val){
+void usrp_e100_impl::rx_dboard_get(const wax::obj &key_, wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     //handle the get request conditioned on the key
@@ -101,7 +101,7 @@ void usrp_e_impl::rx_dboard_get(const wax::obj &key_, wax::obj &val){
 /***********************************************************************
  * RX Dboard Set
  **********************************************************************/
-void usrp_e_impl::rx_dboard_set(const wax::obj &key, const wax::obj &val){
+void usrp_e100_impl::rx_dboard_set(const wax::obj &key, const wax::obj &val){
     switch(key.as<dboard_prop_t>()){
     case DBOARD_PROP_DBOARD_ID:
         _rx_db_eeprom.id = val.as<dboard_id_t>();
@@ -115,7 +115,7 @@ void usrp_e_impl::rx_dboard_set(const wax::obj &key, const wax::obj &val){
 /***********************************************************************
  * TX Dboard Get
  **********************************************************************/
-void usrp_e_impl::tx_dboard_get(const wax::obj &key_, wax::obj &val){
+void usrp_e100_impl::tx_dboard_get(const wax::obj &key_, wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     //handle the get request conditioned on the key
@@ -160,7 +160,7 @@ void usrp_e_impl::tx_dboard_get(const wax::obj &key_, wax::obj &val){
 /***********************************************************************
  * TX Dboard Set
  **********************************************************************/
-void usrp_e_impl::tx_dboard_set(const wax::obj &key, const wax::obj &val){
+void usrp_e100_impl::tx_dboard_set(const wax::obj &key, const wax::obj &val){
     switch(key.as<dboard_prop_t>()){
     case DBOARD_PROP_DBOARD_ID:
         _tx_db_eeprom.id = val.as<dboard_id_t>();
diff --git a/host/lib/usrp/usrp_e100/dsp_impl.cpp b/host/lib/usrp/usrp_e100/dsp_impl.cpp
index 97f173c1a..43a3bd3be 100644
--- a/host/lib/usrp/usrp_e100/dsp_impl.cpp
+++ b/host/lib/usrp/usrp_e100/dsp_impl.cpp
@@ -15,8 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_impl.hpp"
-#include "usrp_e_regs.hpp"
+#include "usrp_e100_impl.hpp"
+#include "usrp_e100_regs.hpp"
 #include <uhd/usrp/dsp_utils.hpp>
 #include <uhd/usrp/dsp_props.hpp>
 #include <boost/math/special_functions/round.hpp>
@@ -30,10 +30,10 @@ using namespace uhd::usrp;
 /***********************************************************************
  * RX DDC Initialization
  **********************************************************************/
-void usrp_e_impl::rx_ddc_init(void){
+void usrp_e100_impl::rx_ddc_init(void){
     _rx_ddc_proxy = wax_obj_proxy::make(
-        boost::bind(&usrp_e_impl::rx_ddc_get, this, _1, _2),
-        boost::bind(&usrp_e_impl::rx_ddc_set, this, _1, _2)
+        boost::bind(&usrp_e100_impl::rx_ddc_get, this, _1, _2),
+        boost::bind(&usrp_e100_impl::rx_ddc_set, this, _1, _2)
     );
 
     //initial config and update
@@ -44,7 +44,7 @@ void usrp_e_impl::rx_ddc_init(void){
 /***********************************************************************
  * RX DDC Get
  **********************************************************************/
-void usrp_e_impl::rx_ddc_get(const wax::obj &key_, wax::obj &val){
+void usrp_e100_impl::rx_ddc_get(const wax::obj &key_, wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     switch(key.as<dsp_prop_t>()){
@@ -79,7 +79,7 @@ void usrp_e_impl::rx_ddc_get(const wax::obj &key_, wax::obj &val){
 /***********************************************************************
  * RX DDC Set
  **********************************************************************/
-void usrp_e_impl::rx_ddc_set(const wax::obj &key_, const wax::obj &val){
+void usrp_e100_impl::rx_ddc_set(const wax::obj &key_, const wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     switch(key.as<dsp_prop_t>()){
@@ -113,10 +113,10 @@ void usrp_e_impl::rx_ddc_set(const wax::obj &key_, const wax::obj &val){
 /***********************************************************************
  * TX DUC Initialization
  **********************************************************************/
-void usrp_e_impl::tx_duc_init(void){
+void usrp_e100_impl::tx_duc_init(void){
     _tx_duc_proxy = wax_obj_proxy::make(
-        boost::bind(&usrp_e_impl::tx_duc_get, this, _1, _2),
-        boost::bind(&usrp_e_impl::tx_duc_set, this, _1, _2)
+        boost::bind(&usrp_e100_impl::tx_duc_get, this, _1, _2),
+        boost::bind(&usrp_e100_impl::tx_duc_set, this, _1, _2)
     );
 
     //initial config and update
@@ -127,7 +127,7 @@ void usrp_e_impl::tx_duc_init(void){
 /***********************************************************************
  * TX DUC Get
  **********************************************************************/
-void usrp_e_impl::tx_duc_get(const wax::obj &key_, wax::obj &val){
+void usrp_e100_impl::tx_duc_get(const wax::obj &key_, wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     switch(key.as<dsp_prop_t>()){
@@ -162,7 +162,7 @@ void usrp_e_impl::tx_duc_get(const wax::obj &key_, wax::obj &val){
 /***********************************************************************
  * TX DUC Set
  **********************************************************************/
-void usrp_e_impl::tx_duc_set(const wax::obj &key_, const wax::obj &val){
+void usrp_e100_impl::tx_duc_set(const wax::obj &key_, const wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     switch(key.as<dsp_prop_t>()){
diff --git a/host/lib/usrp/usrp_e100/fpga-downloader.cc b/host/lib/usrp/usrp_e100/fpga-downloader.cc
index 4dc537919..4a3d3b9af 100644
--- a/host/lib/usrp/usrp_e100/fpga-downloader.cc
+++ b/host/lib/usrp/usrp_e100/fpga-downloader.cc
@@ -253,7 +253,7 @@ int main(int argc, char *argv[])
 }
 */
 
-void usrp_e_load_fpga(const std::string &bin_file){
+void usrp_e100_load_fpga(const std::string &bin_file){
 	gpio gpio_prog_b(PROG_B, OUT);
 	gpio gpio_init_b(INIT_B, IN);
 	gpio gpio_done  (DONE,   IN);
diff --git a/host/lib/usrp/usrp_e100/io_impl.cpp b/host/lib/usrp/usrp_e100/io_impl.cpp
index e863944e8..7cb3e25e5 100644
--- a/host/lib/usrp/usrp_e100/io_impl.cpp
+++ b/host/lib/usrp/usrp_e100/io_impl.cpp
@@ -15,8 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_impl.hpp"
-#include "usrp_e_regs.hpp"
+#include "usrp_e100_impl.hpp"
+#include "usrp_e100_regs.hpp"
 #include <uhd/usrp/dsp_utils.hpp>
 #include <uhd/utils/thread_priority.hpp>
 #include <uhd/transport/bounded_buffer.hpp>
@@ -30,7 +30,7 @@ using namespace uhd;
 using namespace uhd::usrp;
 using namespace uhd::transport;
 
-zero_copy_if::sptr usrp_e_make_mmap_zero_copy(usrp_e_iface::sptr iface);
+zero_copy_if::sptr usrp_e100_make_mmap_zero_copy(usrp_e100_iface::sptr iface);
 
 /***********************************************************************
  * Constants
@@ -46,14 +46,14 @@ static const bool recv_debug = false;
  * - thread loop
  * - vrt packet handler states
  **********************************************************************/
-struct usrp_e_impl::io_impl{
+struct usrp_e100_impl::io_impl{
     //state management for the vrt packet handler code
     vrt_packet_handler::recv_state packet_handler_recv_state;
     vrt_packet_handler::send_state packet_handler_send_state;
     zero_copy_if::sptr data_xport;
     bool continuous_streaming;
-    io_impl(usrp_e_iface::sptr iface):
-        data_xport(usrp_e_make_mmap_zero_copy(iface)),
+    io_impl(usrp_e100_iface::sptr iface):
+        data_xport(usrp_e100_make_mmap_zero_copy(iface)),
         recv_pirate_booty(recv_booty_type::make(data_xport->get_num_recv_frames())),
         async_msg_fifo(bounded_buffer<async_metadata_t>::make(100/*messages deep*/))
     {
@@ -73,7 +73,7 @@ struct usrp_e_impl::io_impl{
     }
 
     //a pirate's life is the life for me!
-    void recv_pirate_loop(usrp_e_clock_ctrl::sptr);
+    void recv_pirate_loop(usrp_e100_clock_ctrl::sptr);
     typedef bounded_buffer<managed_recv_buffer::sptr> recv_booty_type;
     recv_booty_type::sptr recv_pirate_booty;
     bounded_buffer<async_metadata_t>::sptr async_msg_fifo;
@@ -86,7 +86,7 @@ struct usrp_e_impl::io_impl{
  * - while raiding, loot for recv buffers
  * - put booty into the alignment buffer
  **********************************************************************/
-void usrp_e_impl::io_impl::recv_pirate_loop(usrp_e_clock_ctrl::sptr clock_ctrl)
+void usrp_e100_impl::io_impl::recv_pirate_loop(usrp_e100_clock_ctrl::sptr clock_ctrl)
 {
     set_thread_priority_safe();
     recv_pirate_crew_raiding = true;
@@ -140,7 +140,7 @@ void usrp_e_impl::io_impl::recv_pirate_loop(usrp_e_clock_ctrl::sptr clock_ctrl)
 /***********************************************************************
  * Helper Functions
  **********************************************************************/
-void usrp_e_impl::io_init(void){
+void usrp_e100_impl::io_init(void){
     //setup otw types
     _send_otw_type.width = 16;
     _send_otw_type.shift = 0;
@@ -172,11 +172,11 @@ void usrp_e_impl::io_init(void){
 
     //spawn a pirate, yarrr!
     _io_impl->recv_pirate_crew.create_thread(boost::bind(
-        &usrp_e_impl::io_impl::recv_pirate_loop, _io_impl.get(), _clock_ctrl
+        &usrp_e100_impl::io_impl::recv_pirate_loop, _io_impl.get(), _clock_ctrl
     ));
 }
 
-void usrp_e_impl::issue_stream_cmd(const stream_cmd_t &stream_cmd){
+void usrp_e100_impl::issue_stream_cmd(const stream_cmd_t &stream_cmd){
     _io_impl->continuous_streaming = (stream_cmd.stream_mode == stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
     _iface->poke32(UE_REG_CTRL_RX_STREAM_CMD, dsp_type1::calc_stream_cmd_word(
         stream_cmd, get_max_recv_samps_per_packet()
@@ -185,7 +185,7 @@ void usrp_e_impl::issue_stream_cmd(const stream_cmd_t &stream_cmd){
     _iface->poke32(UE_REG_CTRL_RX_TIME_TICKS, stream_cmd.time_spec.get_tick_count(_clock_ctrl->get_fpga_clock_rate()));
 }
 
-void usrp_e_impl::handle_overrun(size_t){
+void usrp_e100_impl::handle_overrun(size_t){
     std::cerr << "O"; //the famous OOOOOOOOOOO
     _iface->poke32(UE_REG_CTRL_RX_CLEAR_OVERRUN, 0);
     if (_io_impl->continuous_streaming){
@@ -205,7 +205,7 @@ bool get_send_buffs(
     return buffs[0].get() != NULL;
 }
 
-size_t usrp_e_impl::get_max_send_samps_per_packet(void) const{
+size_t usrp_e100_impl::get_max_send_samps_per_packet(void) const{
     static const size_t hdr_size = 0
         + vrt::max_if_hdr_words32*sizeof(boost::uint32_t)
         - sizeof(vrt::if_packet_info_t().cid) //no class id ever used
@@ -214,7 +214,7 @@ size_t usrp_e_impl::get_max_send_samps_per_packet(void) const{
     return bpp/_send_otw_type.get_sample_size();
 }
 
-size_t usrp_e_impl::send(
+size_t usrp_e100_impl::send(
     const std::vector<const void *> &buffs, size_t num_samps,
     const tx_metadata_t &metadata, const io_type_t &io_type,
     send_mode_t send_mode, double timeout
@@ -234,7 +234,7 @@ size_t usrp_e_impl::send(
 /***********************************************************************
  * Data Recv
  **********************************************************************/
-size_t usrp_e_impl::get_max_recv_samps_per_packet(void) const{
+size_t usrp_e100_impl::get_max_recv_samps_per_packet(void) const{
     static const size_t hdr_size = 0
         + vrt::max_if_hdr_words32*sizeof(boost::uint32_t)
         + sizeof(vrt::if_packet_info_t().tlr) //forced to have trailer
@@ -244,7 +244,7 @@ size_t usrp_e_impl::get_max_recv_samps_per_packet(void) const{
     return bpp/_recv_otw_type.get_sample_size();
 }
 
-size_t usrp_e_impl::recv(
+size_t usrp_e100_impl::recv(
     const std::vector<void *> &buffs, size_t num_samps,
     rx_metadata_t &metadata, const io_type_t &io_type,
     recv_mode_t recv_mode, double timeout
@@ -256,15 +256,15 @@ size_t usrp_e_impl::recv(
         io_type, _recv_otw_type,                   //input and output types to convert
         _clock_ctrl->get_fpga_clock_rate(),        //master clock tick rate
         uhd::transport::vrt::if_hdr_unpack_le,
-        boost::bind(&usrp_e_impl::io_impl::get_recv_buffs, _io_impl.get(), _1, timeout),
-        boost::bind(&usrp_e_impl::handle_overrun, this, _1)
+        boost::bind(&usrp_e100_impl::io_impl::get_recv_buffs, _io_impl.get(), _1, timeout),
+        boost::bind(&usrp_e100_impl::handle_overrun, this, _1)
     );
 }
 
 /***********************************************************************
  * Async Recv
  **********************************************************************/
-bool usrp_e_impl::recv_async_msg(
+bool usrp_e100_impl::recv_async_msg(
     async_metadata_t &async_metadata, double timeout
 ){
     boost::this_thread::disable_interruption di; //disable because the wait can throw
diff --git a/host/lib/usrp/usrp_e100/mboard_impl.cpp b/host/lib/usrp/usrp_e100/mboard_impl.cpp
index f0118aa4b..2d5d028e6 100644
--- a/host/lib/usrp/usrp_e100/mboard_impl.cpp
+++ b/host/lib/usrp/usrp_e100/mboard_impl.cpp
@@ -15,8 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_impl.hpp"
-#include "usrp_e_regs.hpp"
+#include "usrp_e100_impl.hpp"
+#include "usrp_e100_regs.hpp"
 #include <uhd/usrp/dsp_utils.hpp>
 #include <uhd/usrp/misc_utils.hpp>
 #include <uhd/utils/assert.hpp>
@@ -30,10 +30,10 @@ using namespace uhd::usrp;
 /***********************************************************************
  * Mboard Initialization
  **********************************************************************/
-void usrp_e_impl::mboard_init(void){
+void usrp_e100_impl::mboard_init(void){
     _mboard_proxy = wax_obj_proxy::make(
-        boost::bind(&usrp_e_impl::mboard_get, this, _1, _2),
-        boost::bind(&usrp_e_impl::mboard_set, this, _1, _2)
+        boost::bind(&usrp_e100_impl::mboard_get, this, _1, _2),
+        boost::bind(&usrp_e100_impl::mboard_set, this, _1, _2)
     );
 
     //init the clock config
@@ -46,7 +46,7 @@ void usrp_e_impl::mboard_init(void){
 /***********************************************************************
  * Mboard Get
  **********************************************************************/
-void usrp_e_impl::mboard_get(const wax::obj &key_, wax::obj &val){
+void usrp_e100_impl::mboard_get(const wax::obj &key_, wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     //handle the get request conditioned on the key
@@ -114,7 +114,7 @@ void usrp_e_impl::mboard_get(const wax::obj &key_, wax::obj &val){
 /***********************************************************************
  * Mboard Set
  **********************************************************************/
-void usrp_e_impl::mboard_set(const wax::obj &key, const wax::obj &val){
+void usrp_e100_impl::mboard_set(const wax::obj &key, const wax::obj &val){
     //handle the get request conditioned on the key
     switch(key.as<mboard_prop_t>()){
 
diff --git a/host/lib/usrp/usrp_e100/usrp_e_iface.cpp b/host/lib/usrp/usrp_e100/usrp_e100_iface.cpp
index f00e92946..ad623777e 100644
--- a/host/lib/usrp/usrp_e100/usrp_e_iface.cpp
+++ b/host/lib/usrp/usrp_e100/usrp_e100_iface.cpp
@@ -15,7 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_iface.hpp"
+#include "usrp_e100_iface.hpp"
 #include <uhd/utils/assert.hpp>
 #include <sys/ioctl.h> //ioctl
 #include <fcntl.h> //open, close
@@ -26,7 +26,7 @@
 
 using namespace uhd;
 
-class usrp_e_iface_impl : public usrp_e_iface{
+class usrp_e100_iface_impl : public usrp_e100_iface{
 public:
 
     int get_file_descriptor(void){
@@ -36,7 +36,7 @@ public:
     /*******************************************************************
      * Structors
      ******************************************************************/
-    usrp_e_iface_impl(const std::string &node){
+    usrp_e100_iface_impl(const std::string &node){
         //open the device node and check file descriptor
         if ((_node_fd = ::open(node.c_str(), O_RDWR)) < 0){
             throw std::runtime_error(str(
@@ -45,7 +45,7 @@ public:
         }
     }
 
-    ~usrp_e_iface_impl(void){
+    ~usrp_e100_iface_impl(void){
         //close the device node file descriptor
         ::close(_node_fd);
     }
@@ -189,6 +189,6 @@ private:
 /***********************************************************************
  * Public Make Function
  **********************************************************************/
-usrp_e_iface::sptr usrp_e_iface::make(const std::string &node){
-    return sptr(new usrp_e_iface_impl(node));
+usrp_e100_iface::sptr usrp_e100_iface::make(const std::string &node){
+    return sptr(new usrp_e100_iface_impl(node));
 }
diff --git a/host/lib/usrp/usrp_e100/usrp_e_iface.hpp b/host/lib/usrp/usrp_e100/usrp_e100_iface.hpp
index 59aac43d9..b52209a42 100644
--- a/host/lib/usrp/usrp_e100/usrp_e_iface.hpp
+++ b/host/lib/usrp/usrp_e100/usrp_e100_iface.hpp
@@ -15,8 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#ifndef INCLUDED_USRP_E_IFACE_HPP
-#define INCLUDED_USRP_E_IFACE_HPP
+#ifndef INCLUDED_USRP_E100_IFACE_HPP
+#define INCLUDED_USRP_E100_IFACE_HPP
 
 #include <uhd/transport/udp_simple.hpp>
 #include <uhd/types/serial.hpp>
@@ -38,9 +38,9 @@
  * Provides a set of functions to implementation layer.
  * Including spi, peek, poke, control...
  */
-class usrp_e_iface : boost::noncopyable, public uhd::i2c_iface{
+class usrp_e100_iface : boost::noncopyable, public uhd::i2c_iface{
 public:
-    typedef boost::shared_ptr<usrp_e_iface> sptr;
+    typedef boost::shared_ptr<usrp_e100_iface> sptr;
 
     /*!
      * Make a new usrp-e interface with the control transport.
@@ -109,4 +109,4 @@ public:
     ) = 0;
 };
 
-#endif /* INCLUDED_USRP_E_IFACE_HPP */
+#endif /* INCLUDED_USRP_E100_IFACE_HPP */
diff --git a/host/lib/usrp/usrp_e100/usrp_e_impl.cpp b/host/lib/usrp/usrp_e100/usrp_e100_impl.cpp
index 70cc399fb..73cb1f285 100644
--- a/host/lib/usrp/usrp_e100/usrp_e_impl.cpp
+++ b/host/lib/usrp/usrp_e100/usrp_e100_impl.cpp
@@ -15,8 +15,8 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_impl.hpp"
-#include "usrp_e_regs.hpp"
+#include "usrp_e100_impl.hpp"
+#include "usrp_e100_regs.hpp"
 #include <uhd/usrp/device_props.hpp>
 #include <uhd/usrp/mboard_props.hpp>
 #include <uhd/utils/assert.hpp>
@@ -42,17 +42,17 @@ static std::string abs_path(const std::string &file_path){
 /***********************************************************************
  * Discovery
  **********************************************************************/
-static device_addrs_t usrp_e_find(const device_addr_t &hint){
-    device_addrs_t usrp_e_addrs;
+static device_addrs_t usrp_e100_find(const device_addr_t &hint){
+    device_addrs_t usrp_e100_addrs;
 
     //return an empty list of addresses when type is set to non-usrp-e
-    if (hint.has_key("type") and hint["type"] != "usrp-e") return usrp_e_addrs;
+    if (hint.has_key("type") and hint["type"] != "usrp-e") return usrp_e100_addrs;
 
     //device node not provided, assume its 0
     if (not hint.has_key("node")){
         device_addr_t new_addr = hint;
-        new_addr["node"] = "/dev/usrp_e0";
-        return usrp_e_find(new_addr);
+        new_addr["node"] = "/dev/usrp_e1000";
+        return usrp_e100_find(new_addr);
     }
 
     //use the given device node name
@@ -60,21 +60,21 @@ static device_addrs_t usrp_e_find(const device_addr_t &hint){
         device_addr_t new_addr;
         new_addr["type"] = "usrp-e";
         new_addr["node"] = abs_path(hint["node"]);
-        usrp_e_addrs.push_back(new_addr);
+        usrp_e100_addrs.push_back(new_addr);
     }
 
-    return usrp_e_addrs;
+    return usrp_e100_addrs;
 }
 
 /***********************************************************************
  * Make
  **********************************************************************/
-static device::sptr usrp_e_make(const device_addr_t &device_addr){
+static device::sptr usrp_e100_make(const device_addr_t &device_addr){
 
     //setup the main interface into fpga
     std::string node = device_addr["node"];
     std::cout << boost::format("Opening USRP-E on %s") % node << std::endl;
-    usrp_e_iface::sptr iface = usrp_e_iface::make(node);
+    usrp_e100_iface::sptr iface = usrp_e100_iface::make(node);
 
     //------------------------------------------------------------------
     //-- Handle the FPGA loading...
@@ -82,19 +82,19 @@ static device::sptr usrp_e_make(const device_addr_t &device_addr){
     //--   1) The compatibility number matches.
     //--   2) The hash in the hash-file matches.
     //------------------------------------------------------------------
-    static const char *hash_file_path = "/tmp/usrp_e100_hash";
+    static const char *hash_file_path = "/tmp/usrp_e100100_hash";
 
     //extract the fpga path for usrp-e
-    std::string usrp_e_fpga_image = find_image_path(
-        device_addr.has_key("fpga")? device_addr["fpga"] : "usrp_e100_fpga.bin"
+    std::string usrp_e100_fpga_image = find_image_path(
+        device_addr.has_key("fpga")? device_addr["fpga"] : "usrp_e100100_fpga.bin"
     );
 
     //calculate a hash of the fpga file
     size_t fpga_hash = 0;
     {
-        std::ifstream file(usrp_e_fpga_image.c_str());
+        std::ifstream file(usrp_e100_fpga_image.c_str());
         if (not file.good()) throw std::runtime_error(
-            "cannot open fpga file for read: " + usrp_e_fpga_image
+            "cannot open fpga file for read: " + usrp_e100_fpga_image
         );
         do{
             boost::hash_combine(fpga_hash, file.get());
@@ -112,9 +112,9 @@ static device::sptr usrp_e_make(const device_addr_t &device_addr){
     //if not loaded: load the fpga image and write the hash-file
     if (fpga_compat_num != USRP_E_COMPAT_NUM or loaded_hash != fpga_hash){
         iface.reset();
-        usrp_e_load_fpga(usrp_e_fpga_image);
+        usrp_e100_load_fpga(usrp_e100_fpga_image);
         std::cout << boost::format("re-Opening USRP-E on %s") % node << std::endl;
-        iface = usrp_e_iface::make(node);
+        iface = usrp_e100_iface::make(node);
         try{std::ofstream(hash_file_path) << fpga_hash;}catch(...){}
     }
 
@@ -127,21 +127,21 @@ static device::sptr usrp_e_make(const device_addr_t &device_addr){
         ) % USRP_E_COMPAT_NUM % fpga_compat_num));
     }
 
-    return device::sptr(new usrp_e_impl(iface));
+    return device::sptr(new usrp_e100_impl(iface));
 }
 
-UHD_STATIC_BLOCK(register_usrp_e_device){
-    device::register_device(&usrp_e_find, &usrp_e_make);
+UHD_STATIC_BLOCK(register_usrp_e100_device){
+    device::register_device(&usrp_e100_find, &usrp_e100_make);
 }
 
 /***********************************************************************
  * Structors
  **********************************************************************/
-usrp_e_impl::usrp_e_impl(usrp_e_iface::sptr iface): _iface(iface){
+usrp_e100_impl::usrp_e100_impl(usrp_e100_iface::sptr iface): _iface(iface){
 
     //setup interfaces into hardware
-    _clock_ctrl = usrp_e_clock_ctrl::make(_iface);
-    _codec_ctrl = usrp_e_codec_ctrl::make(_iface);
+    _clock_ctrl = usrp_e100_clock_ctrl::make(_iface);
+    _codec_ctrl = usrp_e100_codec_ctrl::make(_iface);
 
     //initialize the mboard
     mboard_init();
@@ -164,14 +164,14 @@ usrp_e_impl::usrp_e_impl(usrp_e_iface::sptr iface): _iface(iface){
     this->mboard_set(MBOARD_PROP_TX_SUBDEV_SPEC, subdev_spec_t());
 }
 
-usrp_e_impl::~usrp_e_impl(void){
+usrp_e100_impl::~usrp_e100_impl(void){
     /* NOP */
 }
 
 /***********************************************************************
  * Device Get
  **********************************************************************/
-void usrp_e_impl::get(const wax::obj &key_, wax::obj &val){
+void usrp_e100_impl::get(const wax::obj &key_, wax::obj &val){
     named_prop_t key = named_prop_t::extract(key_);
 
     //handle the get request conditioned on the key
@@ -196,6 +196,6 @@ void usrp_e_impl::get(const wax::obj &key_, wax::obj &val){
 /***********************************************************************
  * Device Set
  **********************************************************************/
-void usrp_e_impl::set(const wax::obj &, const wax::obj &){
+void usrp_e100_impl::set(const wax::obj &, const wax::obj &){
     UHD_THROW_PROP_SET_ERROR();
 }
diff --git a/host/lib/usrp/usrp_e100/usrp_e_impl.hpp b/host/lib/usrp/usrp_e100/usrp_e100_impl.hpp
index b5f21810d..fe60ac0be 100644
--- a/host/lib/usrp/usrp_e100/usrp_e_impl.hpp
+++ b/host/lib/usrp/usrp_e100/usrp_e100_impl.hpp
@@ -15,7 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_iface.hpp"
+#include "usrp_e100_iface.hpp"
 #include "clock_ctrl.hpp"
 #include "codec_ctrl.hpp"
 #include <uhd/device.hpp>
@@ -27,13 +27,13 @@
 #include <uhd/types/stream_cmd.hpp>
 #include <uhd/usrp/dboard_manager.hpp>
 
-#ifndef INCLUDED_USRP_E_IMPL_HPP
-#define INCLUDED_USRP_E_IMPL_HPP
+#ifndef INCLUDED_USRP_E100_IMPL_HPP
+#define INCLUDED_USRP_E100_IMPL_HPP
 
 static const boost::uint16_t USRP_E_COMPAT_NUM = 0x02;
 
 //! load an fpga image from a bin file into the usrp-e fpga
-extern void usrp_e_load_fpga(const std::string &bin_file);
+extern void usrp_e100_load_fpga(const std::string &bin_file);
 
 /*!
  * Make a usrp-e dboard interface.
@@ -42,10 +42,10 @@ extern void usrp_e_load_fpga(const std::string &bin_file);
  * \param codec the codec control interface
  * \return a sptr to a new dboard interface
  */
-uhd::usrp::dboard_iface::sptr make_usrp_e_dboard_iface(
-    usrp_e_iface::sptr iface,
-    usrp_e_clock_ctrl::sptr clock,
-    usrp_e_codec_ctrl::sptr codec
+uhd::usrp::dboard_iface::sptr make_usrp_e100_dboard_iface(
+    usrp_e100_iface::sptr iface,
+    usrp_e100_clock_ctrl::sptr clock,
+    usrp_e100_codec_ctrl::sptr codec
 );
 
 /*!
@@ -72,15 +72,15 @@ private:
 };
 
 /*!
- * USRP1E implementation guts:
+ * USRP-E100 implementation guts:
  * The implementation details are encapsulated here.
  * Handles properties on the mboard, dboard, dsps...
  */
-class usrp_e_impl : public uhd::device{
+class usrp_e100_impl : public uhd::device{
 public:
     //structors
-    usrp_e_impl(usrp_e_iface::sptr);
-    ~usrp_e_impl(void);
+    usrp_e100_impl(usrp_e100_iface::sptr);
+    ~usrp_e100_impl(void);
 
     //the io interface
     size_t send(const std::vector<const void *> &, size_t, const uhd::tx_metadata_t &, const uhd::io_type_t &, send_mode_t, double);
@@ -91,7 +91,7 @@ public:
 
 private:
     //interface to ioctls and file descriptor
-    usrp_e_iface::sptr _iface;
+    usrp_e100_iface::sptr _iface;
 
     //handle io stuff
     UHD_PIMPL_DECL(io_impl) _io_impl;
@@ -105,10 +105,10 @@ private:
     //TODO otw type recv/send
 
     //ad9522 clock control
-    usrp_e_clock_ctrl::sptr _clock_ctrl;
+    usrp_e100_clock_ctrl::sptr _clock_ctrl;
 
     //ad9862 codec control
-    usrp_e_codec_ctrl::sptr _codec_ctrl;
+    usrp_e100_codec_ctrl::sptr _codec_ctrl;
 
     //device functions and settings
     void get(const wax::obj &, wax::obj &);
@@ -161,4 +161,4 @@ private:
     wax_obj_proxy::sptr _rx_codec_proxy, _tx_codec_proxy;
 };
 
-#endif /* INCLUDED_USRP_E_IMPL_HPP */
+#endif /* INCLUDED_USRP_E100_IMPL_HPP */
diff --git a/host/lib/usrp/usrp_e100/usrp_e_mmap_zero_copy.cpp b/host/lib/usrp/usrp_e100/usrp_e100_mmap_zero_copy.cpp
index 274bb043e..bf378a9b1 100644
--- a/host/lib/usrp/usrp_e100/usrp_e_mmap_zero_copy.cpp
+++ b/host/lib/usrp/usrp_e100/usrp_e100_mmap_zero_copy.cpp
@@ -15,7 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include "usrp_e_iface.hpp"
+#include "usrp_e100_iface.hpp"
 #include <uhd/transport/zero_copy.hpp>
 #include <uhd/utils/assert.hpp>
 #include <linux/usrp_e.h>
@@ -36,9 +36,9 @@ static const size_t poll_breakout = 10; //how many poll timeouts constitute a fu
 /***********************************************************************
  * The zero copy interface implementation
  **********************************************************************/
-class usrp_e_mmap_zero_copy_impl : public zero_copy_if, public boost::enable_shared_from_this<usrp_e_mmap_zero_copy_impl> {
+class usrp_e100_mmap_zero_copy_impl : public zero_copy_if, public boost::enable_shared_from_this<usrp_e100_mmap_zero_copy_impl> {
 public:
-    usrp_e_mmap_zero_copy_impl(usrp_e_iface::sptr iface):
+    usrp_e100_mmap_zero_copy_impl(usrp_e100_iface::sptr iface):
         _fd(iface->get_file_descriptor()), _recv_index(0), _send_index(0)
     {
         //get system sizes
@@ -91,7 +91,7 @@ public:
         _send_buff = rb_ptr + send_buff_off;
     }
 
-    ~usrp_e_mmap_zero_copy_impl(void){
+    ~usrp_e100_mmap_zero_copy_impl(void){
         if (sp_verbose) std::cout << "cleanup: munmap" << std::endl;
         ::munmap(_mapped_mem, _map_size);
     }
@@ -126,7 +126,7 @@ public:
         if (fp_verbose) std::cout << "  make_recv_buff: " << info->len << std::endl;
         return managed_recv_buffer::make_safe(
             boost::asio::const_buffer(mem, info->len),
-            boost::bind(&usrp_e_mmap_zero_copy_impl::release, shared_from_this(), info)
+            boost::bind(&usrp_e100_mmap_zero_copy_impl::release, shared_from_this(), info)
         );
     }
 
@@ -162,7 +162,7 @@ public:
         if (fp_verbose) std::cout << "  make_send_buff: " << _frame_size << std::endl;
         return managed_send_buffer::make_safe(
             boost::asio::mutable_buffer(mem, _frame_size),
-            boost::bind(&usrp_e_mmap_zero_copy_impl::commit, shared_from_this(), info, _1)
+            boost::bind(&usrp_e100_mmap_zero_copy_impl::commit, shared_from_this(), info, _1)
         );
     }
 
@@ -210,6 +210,6 @@ private:
 /***********************************************************************
  * The zero copy interface make function
  **********************************************************************/
-zero_copy_if::sptr usrp_e_make_mmap_zero_copy(usrp_e_iface::sptr iface){
-    return zero_copy_if::sptr(new usrp_e_mmap_zero_copy_impl(iface));
+zero_copy_if::sptr usrp_e100_make_mmap_zero_copy(usrp_e100_iface::sptr iface){
+    return zero_copy_if::sptr(new usrp_e100_mmap_zero_copy_impl(iface));
 }
diff --git a/host/lib/usrp/usrp_e100/usrp_e_regs.hpp b/host/lib/usrp/usrp_e100/usrp_e100_regs.hpp
index 8bfb08b6f..625fb2c35 100644
--- a/host/lib/usrp/usrp_e100/usrp_e_regs.hpp
+++ b/host/lib/usrp/usrp_e100/usrp_e100_regs.hpp
@@ -10,8 +10,8 @@
 //  This means that address bit 0 is usually 0.
 //  There are 11 bits of address for the control.
 
-#ifndef __USRP_E_REGS_H
-#define __USRP_E_REGS_H
+#ifndef INCLUDED_USRP_E100_REGS_HPP
+#define INCLUDED_USRP_E100_REGS_HPP
 
 /////////////////////////////////////////////////////
 // Slave pointers