usrp2: work on alternative OTW formats

8 files changed, 126 insertions, 29 deletions

diff --git a/host/lib/convert/convert_common.hpp b/host/lib/convert/convert_common.hpp
index 612fa312b..56b718292 100644
--- a/host/lib/convert/convert_common.hpp
+++ b/host/lib/convert/convert_common.hpp
@@ -65,18 +65,18 @@ typedef boost::int8_t                s8_t;
 typedef boost::uint32_t              item32_t;
 
 /***********************************************************************
- * Convert complex short buffer to items32
+ * Convert complex short buffer to items32 sc16
  **********************************************************************/
-static UHD_INLINE item32_t sc16_to_item32(sc16_t num, double){
+static UHD_INLINE item32_t sc16_to_item32_sc16(sc16_t num, double){
     boost::uint16_t real = num.real();
     boost::uint16_t imag = num.imag();
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
 /***********************************************************************
- * Convert items32 buffer to complex short
+ * Convert items32 sc16 buffer to complex short
  **********************************************************************/
-static UHD_INLINE sc16_t item32_to_sc16(item32_t item, double){
+static UHD_INLINE sc16_t item32_sc16_to_sc16(item32_t item, double){
     return sc16_t(
         boost::int16_t(item >> 16),
         boost::int16_t(item >> 0)
@@ -84,18 +84,18 @@ static UHD_INLINE sc16_t item32_to_sc16(item32_t item, double){
 }
 
 /***********************************************************************
- * Convert complex float buffer to items32 (no swap)
+ * Convert complex float buffer to items32 sc16
  **********************************************************************/
-static UHD_INLINE item32_t fc32_to_item32(fc32_t num, double scale_factor){
+static UHD_INLINE item32_t fc32_to_item32_sc16(fc32_t num, double scale_factor){
     boost::uint16_t real = boost::int16_t(num.real()*float(scale_factor));
     boost::uint16_t imag = boost::int16_t(num.imag()*float(scale_factor));
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
 /***********************************************************************
- * Convert items32 buffer to complex float
+ * Convert items32 sc16 buffer to complex float
  **********************************************************************/
-static UHD_INLINE fc32_t item32_to_fc32(item32_t item, double scale_factor){
+static UHD_INLINE fc32_t item32_sc16_to_fc32(item32_t item, double scale_factor){
     return fc32_t(
         float(boost::int16_t(item >> 16)*float(scale_factor)),
         float(boost::int16_t(item >> 0)*float(scale_factor))
@@ -103,22 +103,64 @@ static UHD_INLINE fc32_t item32_to_fc32(item32_t item, double scale_factor){
 }
 
 /***********************************************************************
- * Convert complex double buffer to items32 (no swap)
+ * Convert complex double buffer to items32 sc16
  **********************************************************************/
-static UHD_INLINE item32_t fc64_to_item32(fc64_t num, double scale_factor){
+static UHD_INLINE item32_t fc64_to_item32_sc16(fc64_t num, double scale_factor){
     boost::uint16_t real = boost::int16_t(num.real()*scale_factor);
     boost::uint16_t imag = boost::int16_t(num.imag()*scale_factor);
     return (item32_t(real) << 16) | (item32_t(imag) << 0);
 }
 
 /***********************************************************************
- * Convert items32 buffer to complex double
+ * Convert items32 sc16 buffer to complex double
  **********************************************************************/
-static UHD_INLINE fc64_t item32_to_fc64(item32_t item, double scale_factor){
+static UHD_INLINE fc64_t item32_sc16_to_fc64(item32_t item, double scale_factor){
     return fc64_t(
         float(boost::int16_t(item >> 16)*scale_factor),
         float(boost::int16_t(item >> 0)*scale_factor)
     );
 }
 
+/***********************************************************************
+ * Convert items32 sc8 buffer to complex short
+ **********************************************************************/
+static UHD_INLINE void item32_sc8_to_sc16(item32_t item, sc16_t &out0, sc16_t &out1, double){
+    out0 = sc16_t(
+        boost::int8_t(item >> 8),
+        boost::int8_t(item >> 0)
+    );
+    out1 = sc16_t(
+        boost::int8_t(item >> 24),
+        boost::int8_t(item >> 16)
+    );
+}
+
+/***********************************************************************
+ * Convert items32 sc8 buffer to complex float
+ **********************************************************************/
+static UHD_INLINE void item32_sc8_to_fc32(item32_t item, fc32_t &out0, fc32_t &out1, double scale_factor){
+    out0 = fc32_t(
+        float(boost::int8_t(item >> 8)*float(scale_factor)),
+        float(boost::int8_t(item >> 0)*float(scale_factor))
+    );
+    out1 = fc32_t(
+        float(boost::int8_t(item >> 24)*float(scale_factor)),
+        float(boost::int8_t(item >> 16)*float(scale_factor))
+    );
+}
+
+/***********************************************************************
+ * Convert items32 sc8 buffer to complex double
+ **********************************************************************/
+static UHD_INLINE void item32_sc8_to_fc64(item32_t item, fc64_t &out0, fc64_t &out1, double scale_factor){
+    out0 = fc64_t(
+        float(boost::int8_t(item >> 8)*scale_factor),
+        float(boost::int8_t(item >> 0)*scale_factor)
+    );
+    out1 = fc64_t(
+        float(boost::int8_t(item >> 24)*scale_factor),
+        float(boost::int8_t(item >> 16)*scale_factor)
+    );
+}
+
 #endif /* INCLUDED_LIBUHD_CONVERT_COMMON_HPP */
diff --git a/host/lib/convert/convert_fc32_with_sse2.cpp b/host/lib/convert/convert_fc32_with_sse2.cpp
index 34c85db80..b8d1aa8cc 100644
--- a/host/lib/convert/convert_fc32_with_sse2.cpp
+++ b/host/lib/convert/convert_fc32_with_sse2.cpp
@@ -51,7 +51,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
     //dispatch according to alignment
     switch (size_t(input) & 0xf){
     case 0x8:
-        output[i] = fc32_to_item32(input[i], float(scale_factor)); i++;
+        output[i] = fc32_to_item32_sc16(input[i], float(scale_factor)); i++;
     case 0x0:
         convert_fc32_1_to_item32_1_nswap_guts(_)
         break;
@@ -60,7 +60,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = fc32_to_item32(input[i], float(scale_factor));
+        output[i] = fc32_to_item32_sc16(input[i], float(scale_factor));
     }
 }
 
@@ -93,7 +93,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
     //dispatch according to alignment
     switch (size_t(input) & 0xf){
     case 0x8:
-        output[i] = uhd::byteswap(fc32_to_item32(input[i], float(scale_factor))); i++;
+        output[i] = uhd::byteswap(fc32_to_item32_sc16(input[i], float(scale_factor))); i++;
     case 0x0:
         convert_fc32_1_to_item32_1_bswap_guts(_)
         break;
@@ -102,7 +102,7 @@ DECLARE_CONVERTER(fc32, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = uhd::byteswap(fc32_to_item32(input[i], float(scale_factor)));
+        output[i] = uhd::byteswap(fc32_to_item32_sc16(input[i], float(scale_factor)));
     }
 }
 
@@ -138,7 +138,7 @@ DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_CUSTOM){
     //dispatch according to alignment
     switch (size_t(output) & 0xf){
     case 0x8:
-        output[i] = item32_to_fc32(input[i], float(scale_factor)); i++;
+        output[i] = item32_sc16_to_fc32(input[i], float(scale_factor)); i++;
     case 0x0:
         convert_item32_1_to_fc32_1_nswap_guts(_)
         break;
@@ -147,7 +147,7 @@ DECLARE_CONVERTER(sc16_item32_le, 1, fc32, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = item32_to_fc32(input[i], float(scale_factor));
+        output[i] = item32_sc16_to_fc32(input[i], float(scale_factor));
     }
 }
 
@@ -182,7 +182,7 @@ DECLARE_CONVERTER(sc16_item32_be, 1, fc32, 1, PRIORITY_CUSTOM){
     //dispatch according to alignment
     switch (size_t(output) & 0xf){
     case 0x8:
-        output[i] = item32_to_fc32(uhd::byteswap(input[i]), float(scale_factor)); i++;
+        output[i] = item32_sc16_to_fc32(uhd::byteswap(input[i]), float(scale_factor)); i++;
     case 0x0:
         convert_item32_1_to_fc32_1_bswap_guts(_)
         break;
@@ -191,6 +191,6 @@ DECLARE_CONVERTER(sc16_item32_be, 1, fc32, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = item32_to_fc32(uhd::byteswap(input[i]), float(scale_factor));
+        output[i] = item32_sc16_to_fc32(uhd::byteswap(input[i]), float(scale_factor));
     }
 }
diff --git a/host/lib/convert/convert_fc64_with_sse2.cpp b/host/lib/convert/convert_fc64_with_sse2.cpp
index 2093cf476..a4f2df2e7 100644
--- a/host/lib/convert/convert_fc64_with_sse2.cpp
+++ b/host/lib/convert/convert_fc64_with_sse2.cpp
@@ -64,7 +64,7 @@ DECLARE_CONVERTER(fc64, 1, sc16_item32_le, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = fc64_to_item32(input[i], scale_factor);
+        output[i] = fc64_to_item32_sc16(input[i], scale_factor);
     }
 }
 
@@ -110,7 +110,7 @@ DECLARE_CONVERTER(fc64, 1, sc16_item32_be, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = uhd::byteswap(fc64_to_item32(input[i], scale_factor));
+        output[i] = uhd::byteswap(fc64_to_item32_sc16(input[i], scale_factor));
     }
 }
 
@@ -159,7 +159,7 @@ DECLARE_CONVERTER(sc16_item32_le, 1, fc64, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = item32_to_fc64(input[i], scale_factor);
+        output[i] = item32_sc16_to_fc64(input[i], scale_factor);
     }
 }
 
@@ -207,6 +207,6 @@ DECLARE_CONVERTER(sc16_item32_be, 1, fc64, 1, PRIORITY_CUSTOM){
 
     //convert remainder
     for (; i < nsamps; i++){
-        output[i] = item32_to_fc64(uhd::byteswap(input[i]), scale_factor);
+        output[i] = item32_sc16_to_fc64(uhd::byteswap(input[i]), scale_factor);
     }
 }
diff --git a/host/lib/convert/gen_convert_general.py b/host/lib/convert/gen_convert_general.py
index 0cd4155fa..43e1f9967 100644
--- a/host/lib/convert/gen_convert_general.py
+++ b/host/lib/convert/gen_convert_general.py
@@ -34,7 +34,7 @@ DECLARE_CONVERTER($(cpu_type), 1, sc16_item32_$(end), 1, PRIORITY_GENERAL){
     item32_t *output = reinterpret_cast<item32_t *>(outputs[0]);
 
     for (size_t i = 0; i < nsamps; i++){
-        output[i] = $(to_wire)($(cpu_type)_to_item32(input[i], scale_factor));
+        output[i] = $(to_wire)($(cpu_type)_to_item32_sc16(input[i], scale_factor));
     }
 }
 
@@ -43,7 +43,35 @@ DECLARE_CONVERTER(sc16_item32_$(end), 1, $(cpu_type), 1, PRIORITY_GENERAL){
     $(cpu_type)_t *output = reinterpret_cast<$(cpu_type)_t *>(outputs[0]);
 
     for (size_t i = 0; i < nsamps; i++){
-        output[i] = item32_to_$(cpu_type)($(to_host)(input[i]), scale_factor);
+        output[i] = item32_sc16_to_$(cpu_type)($(to_host)(input[i]), scale_factor);
+    }
+}
+
+DECLARE_CONVERTER(sc8_item32_$(end), 1, $(cpu_type), 1, PRIORITY_GENERAL){
+    const item32_t *input = reinterpret_cast<const item32_t *>(size_t(inputs[0]) & ~0x3);
+    $(cpu_type)_t *output = reinterpret_cast<$(cpu_type)_t *>(outputs[0]);
+    $(cpu_type)_t dummy;
+
+    const bool head_case = ((size_t(inputs[0]) & 0x3) != 0);
+    const bool tail_case = ((nsamps & 0x1) == 0)? head_case : not head_case;
+    const size_t num_pairs = (head_case? nsamps-1 : nsamps)/2;
+    size_t i = 0, j = 0;
+
+    //special head case, probably from a partial recv
+    if (head_case){
+        const item32_t item0 = $(to_host)(input[i++]);
+        item32_sc8_to_$(cpu_type)(item0, dummy, output[j++], scale_factor);
+    }
+
+    for (; i < num_pairs; i++, j+=2){
+        const item32_t item_i = $(to_host)(input[i]);
+        item32_sc8_to_$(cpu_type)(item_i, output[j], output[j+1], scale_factor);
+    }
+
+    //special tail case, finished on an odd number
+    if (tail_case){
+        const item32_t item_i = $(to_host)(input[i]);
+        item32_sc8_to_$(cpu_type)(item_i, output[j], dummy, scale_factor);
     }
 }
 """
diff --git a/host/lib/usrp/cores/rx_dsp_core_200.cpp b/host/lib/usrp/cores/rx_dsp_core_200.cpp
index d562c64db..023216a09 100644
--- a/host/lib/usrp/cores/rx_dsp_core_200.cpp
+++ b/host/lib/usrp/cores/rx_dsp_core_200.cpp
@@ -42,6 +42,7 @@
 #define REG_RX_CTRL_VRT_TLR        _ctrl_base + 24
 #define REG_RX_CTRL_NSAMPS_PP      _ctrl_base + 28
 #define REG_RX_CTRL_NCHANNELS      _ctrl_base + 32
+#define REG_RX_CTRL_FORMAT         _ctrl_base + 36
 
 template <class T> T ceil_log2(T num){
     return std::ceil(std::log(num)/std::log(T(2)));
@@ -162,7 +163,7 @@ public:
     }
 
     double get_scaling_adjustment(void){
-        return _scaling_adjustment;
+        return _scaling_adjustment/_fxpt_scale_adj;
     }
 
     double set_freq(const double freq_){
@@ -192,12 +193,28 @@ public:
         if (_continuous_streaming) issue_stream_command(stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
     }
 
+    void set_format(const std::string &format, const unsigned scale){
+        unsigned format_word = 0;
+        if (format == "sc16"){
+            format_word = 0;
+            _fxpt_scale_adj = 32767.;
+        }
+        else if (format == "sc8"){
+            format_word = (1 << 18);
+            _fxpt_scale_adj = 32767./scale;
+        }
+        else throw uhd::value_error("USRP RX cannot handle requested wire format: " + format);
+
+        const unsigned scale_word = scale & 0x3ffff; //18 bits;
+        _iface->poke32(REG_RX_CTRL_FORMAT, format_word | scale_word);
+    }
+
 private:
     wb_iface::sptr _iface;
     const size_t _dsp_base, _ctrl_base;
     double _tick_rate, _link_rate;
     bool _continuous_streaming;
-    double _scaling_adjustment;
+    double _scaling_adjustment, _fxpt_scale_adj;
 };
 
 rx_dsp_core_200::sptr rx_dsp_core_200::make(wb_iface::sptr iface, const size_t dsp_base, const size_t ctrl_base, const boost::uint32_t sid, const bool lingering_packet){
diff --git a/host/lib/usrp/cores/rx_dsp_core_200.hpp b/host/lib/usrp/cores/rx_dsp_core_200.hpp
index 391cc8441..ddd6f2abf 100644
--- a/host/lib/usrp/cores/rx_dsp_core_200.hpp
+++ b/host/lib/usrp/cores/rx_dsp_core_200.hpp
@@ -56,6 +56,7 @@ public:
 
     virtual void handle_overflow(void) = 0;
 
+    virtual void set_format(const std::string &format, const unsigned scale) = 0;
 };
 
 #endif /* INCLUDED_LIBUHD_USRP_RX_DSP_CORE_200_HPP */
diff --git a/host/lib/usrp/usrp1/io_impl.cpp b/host/lib/usrp/usrp1/io_impl.cpp
index 835c78ecc..eaa6d02b4 100644
--- a/host/lib/usrp/usrp1/io_impl.cpp
+++ b/host/lib/usrp/usrp1/io_impl.cpp
@@ -564,6 +564,10 @@ rx_streamer::sptr usrp1_impl::get_rx_stream(const uhd::stream_args_t &args){
     boost::shared_ptr<usrp1_recv_packet_streamer> my_streamer =
         boost::make_shared<usrp1_recv_packet_streamer>(spp, _soft_time_ctrl);
 
+    //special scale factor change for sc8
+    if (args.otw_format == "sc8")
+        my_streamer->set_scale_factor(1.0/127);
+
     //init some streamer stuff
     my_streamer->set_tick_rate(_master_clock_rate);
     my_streamer->set_vrt_unpacker(&usrp1_bs_vrt_unpacker);
diff --git a/host/lib/usrp/usrp2/io_impl.cpp b/host/lib/usrp/usrp2/io_impl.cpp
index d37be403b..f917a35db 100644
--- a/host/lib/usrp/usrp2/io_impl.cpp
+++ b/host/lib/usrp/usrp2/io_impl.cpp
@@ -290,7 +290,7 @@ void usrp2_impl::update_rx_samp_rate(const std::string &mb, const size_t dsp, co
 
     my_streamer->set_samp_rate(rate);
     const double adj = _mbc[mb].rx_dsps[dsp]->get_scaling_adjustment();
-    my_streamer->set_scale_factor(adj/32767.);
+    my_streamer->set_scale_factor(adj);
 }
 
 void usrp2_impl::update_tx_samp_rate(const std::string &mb, const size_t dsp, const double rate){
@@ -404,6 +404,7 @@ rx_streamer::sptr usrp2_impl::get_rx_stream(const uhd::stream_args_t &args){
             if (chan < num_chan_so_far){
                 const size_t dsp = num_chan_so_far - chan - 1;
                 _mbc[mb].rx_dsps[dsp]->set_nsamps_per_packet(spp); //seems to be a good place to set this
+                _mbc[mb].rx_dsps[dsp]->set_format(args.otw_format, 0x400);
                 my_streamer->set_xport_chan_get_buff(chan_i, boost::bind(
                     &zero_copy_if::get_recv_buff, _mbc[mb].rx_dsp_xports[dsp], _1
                 ));
@@ -427,6 +428,10 @@ rx_streamer::sptr usrp2_impl::get_rx_stream(const uhd::stream_args_t &args){
  * Transmit streamer
  **********************************************************************/
 tx_streamer::sptr usrp2_impl::get_tx_stream(const uhd::stream_args_t &args){
+    if (args.otw_format != "sc16"){
+        throw uhd::value_error("USRP TX cannot handle requested wire format: " + args.otw_format);
+    }
+
     //map an empty channel set to chan0
     const std::vector<size_t> channels = args.channels.empty()? std::vector<size_t>(1, 0) : args.channels;