From 9f993843e52b1da877fd579de499e492f602ce81 Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Wed, 28 Aug 2013 17:07:07 -0700 Subject: convert: sc8 swap for vita compliance --- host/lib/convert/convert_common.hpp | 38 ++++++++++++++++---------------- host/lib/convert/convert_orc.orc | 1 - host/lib/convert/convert_with_orc.cpp | 4 ++-- host/lib/convert/convert_with_tables.cpp | 30 ++++++++++++------------- host/lib/convert/sse2_fc32_to_sc8.cpp | 6 ++--- host/lib/convert/sse2_fc64_to_sc8.cpp | 18 +++++++-------- host/lib/convert/sse2_sc8_to_fc32.cpp | 6 ++--- host/lib/convert/sse2_sc8_to_fc64.cpp | 6 ++--- 8 files changed, 54 insertions(+), 55 deletions(-) (limited to 'host') diff --git a/host/lib/convert/convert_common.hpp b/host/lib/convert/convert_common.hpp index 933978a8f..ceaa1151c 100644 --- a/host/lib/convert/convert_common.hpp +++ b/host/lib/convert/convert_common.hpp @@ -1,5 +1,5 @@ // -// Copyright 2011-2012 Ettus Research LLC +// Copyright 2011-2013 Ettus Research LLC // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by @@ -150,10 +150,10 @@ UHD_INLINE void item32_sc16_to_xx( template UHD_INLINE item32_t xx_to_item32_sc8_x1( const std::complex &in0, const std::complex &in1, const double scale_factor ){ - boost::uint8_t real0 = boost::int8_t(in0.real()*float(scale_factor)); - boost::uint8_t imag0 = boost::int8_t(in0.imag()*float(scale_factor)); - boost::uint8_t real1 = boost::int8_t(in1.real()*float(scale_factor)); - boost::uint8_t imag1 = boost::int8_t(in1.imag()*float(scale_factor)); + boost::uint8_t real1 = boost::int8_t(in0.real()*float(scale_factor)); + boost::uint8_t imag1 = boost::int8_t(in0.imag()*float(scale_factor)); + boost::uint8_t real0 = boost::int8_t(in1.real()*float(scale_factor)); + boost::uint8_t imag0 = boost::int8_t(in1.imag()*float(scale_factor)); return (item32_t(real0) << 8) | (item32_t(imag0) << 0) | (item32_t(real1) << 24) | (item32_t(imag1) << 16) @@ -163,10 +163,10 @@ template UHD_INLINE item32_t xx_to_item32_sc8_x1( template <> UHD_INLINE item32_t xx_to_item32_sc8_x1( const sc16_t &in0, const sc16_t &in1, const double ){ - boost::uint8_t real0 = boost::int8_t(in0.real()); - boost::uint8_t imag0 = boost::int8_t(in0.imag()); - boost::uint8_t real1 = boost::int8_t(in1.real()); - boost::uint8_t imag1 = boost::int8_t(in1.imag()); + boost::uint8_t real1 = boost::int8_t(in0.real()); + boost::uint8_t imag1 = boost::int8_t(in0.imag()); + boost::uint8_t real0 = boost::int8_t(in1.real()); + boost::uint8_t imag0 = boost::int8_t(in1.imag()); return (item32_t(real0) << 8) | (item32_t(imag0) << 0) | (item32_t(real1) << 24) | (item32_t(imag1) << 16) @@ -176,10 +176,10 @@ template <> UHD_INLINE item32_t xx_to_item32_sc8_x1( template <> UHD_INLINE item32_t xx_to_item32_sc8_x1( const sc8_t &in0, const sc8_t &in1, const double ){ - boost::uint8_t real0 = boost::int8_t(in0.real()); - boost::uint8_t imag0 = boost::int8_t(in0.imag()); - boost::uint8_t real1 = boost::int8_t(in1.real()); - boost::uint8_t imag1 = boost::int8_t(in1.imag()); + boost::uint8_t real1 = boost::int8_t(in0.real()); + boost::uint8_t imag1 = boost::int8_t(in0.imag()); + boost::uint8_t real0 = boost::int8_t(in1.real()); + boost::uint8_t imag0 = boost::int8_t(in1.imag()); return (item32_t(real0) << 8) | (item32_t(imag0) << 0) | (item32_t(real1) << 24) | (item32_t(imag1) << 16) @@ -211,11 +211,11 @@ UHD_INLINE void xx_to_item32_sc8( template UHD_INLINE void item32_sc8_x1_to_xx( const item32_t item, std::complex &out0, std::complex &out1, const double scale_factor ){ - out0 = std::complex( + out1 = std::complex( T(boost::int8_t(item >> 8)*float(scale_factor)), T(boost::int8_t(item >> 0)*float(scale_factor)) ); - out1 = std::complex( + out0 = std::complex( T(boost::int8_t(item >> 24)*float(scale_factor)), T(boost::int8_t(item >> 16)*float(scale_factor)) ); @@ -224,11 +224,11 @@ template UHD_INLINE void item32_sc8_x1_to_xx( template <> UHD_INLINE void item32_sc8_x1_to_xx( const item32_t item, sc16_t &out0, sc16_t &out1, const double ){ - out0 = sc16_t( + out1 = sc16_t( boost::int16_t(boost::int8_t(item >> 8)), boost::int16_t(boost::int8_t(item >> 0)) ); - out1 = sc16_t( + out0 = sc16_t( boost::int16_t(boost::int8_t(item >> 24)), boost::int16_t(boost::int8_t(item >> 16)) ); @@ -237,11 +237,11 @@ template <> UHD_INLINE void item32_sc8_x1_to_xx( template <> UHD_INLINE void item32_sc8_x1_to_xx( const item32_t item, sc8_t &out0, sc8_t &out1, const double ){ - out0 = sc8_t( + out1 = sc8_t( boost::int8_t(boost::int8_t(item >> 8)), boost::int8_t(boost::int8_t(item >> 0)) ); - out1 = sc8_t( + out0 = sc8_t( boost::int8_t(boost::int8_t(item >> 24)), boost::int8_t(boost::int8_t(item >> 16)) ); diff --git a/host/lib/convert/convert_orc.orc b/host/lib/convert/convert_orc.orc index f7075606e..ffb298f26 100644 --- a/host/lib/convert/convert_orc.orc +++ b/host/lib/convert/convert_orc.orc @@ -75,6 +75,5 @@ swapl dst, src .floatparam 4 scalar x2 mulf tmp, src, scalar x2 convfl tmp, tmp -swaplq tmp, tmp x2 convlw tmp2, tmp x2 convwb dst, tmp2 diff --git a/host/lib/convert/convert_with_orc.cpp b/host/lib/convert/convert_with_orc.cpp index e44c8ca73..19755fa44 100644 --- a/host/lib/convert/convert_with_orc.cpp +++ b/host/lib/convert/convert_with_orc.cpp @@ -1,5 +1,5 @@ // -// Copyright 2011 Ettus Research LLC +// Copyright 2011-2013 Ettus Research LLC // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by @@ -57,9 +57,9 @@ DECLARE_CONVERTER(sc16_item32_le, 1, sc16, 1, PRIORITY_LIBORC){ DECLARE_CONVERTER(fc32, 1, sc8_item32_be, 1, PRIORITY_LIBORC){ _convert_fc32_1_to_sc8_1_nswap_orc(outputs[0], inputs[0], scale_factor, nsamps); - _convert_swap_byte_pairs_orc(outputs[0], outputs[0], (nsamps + 1)/2); } DECLARE_CONVERTER(fc32, 1, sc8_item32_le, 1, PRIORITY_LIBORC){ _convert_fc32_1_to_sc8_1_nswap_orc(outputs[0], inputs[0], scale_factor, nsamps); + _convert_swap_byte_pairs_orc(outputs[0], outputs[0], (nsamps + 1)/2); } diff --git a/host/lib/convert/convert_with_tables.cpp b/host/lib/convert/convert_with_tables.cpp index cd7773d4b..4d295fa01 100644 --- a/host/lib/convert/convert_with_tables.cpp +++ b/host/lib/convert/convert_with_tables.cpp @@ -1,5 +1,5 @@ // -// Copyright 2011-2012 Ettus Research LLC +// Copyright 2011-2013 Ettus Research LLC // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by @@ -59,16 +59,16 @@ public: item32_t lookup(const sc16_t &in0, const sc16_t &in1){ if (swap){ //hope this compiles out, its a template constant return - (item32_t(_table[boost::uint16_t(in0.real())]) << 16) | - (item32_t(_table[boost::uint16_t(in0.imag())]) << 24) | - (item32_t(_table[boost::uint16_t(in1.real())]) << 0) | - (item32_t(_table[boost::uint16_t(in1.imag())]) << 8) ; + (item32_t(_table[boost::uint16_t(in1.real())]) << 16) | + (item32_t(_table[boost::uint16_t(in1.imag())]) << 24) | + (item32_t(_table[boost::uint16_t(in0.real())]) << 0) | + (item32_t(_table[boost::uint16_t(in0.imag())]) << 8) ; } return - (item32_t(_table[boost::uint16_t(in0.real())]) << 8) | - (item32_t(_table[boost::uint16_t(in0.imag())]) << 0) | - (item32_t(_table[boost::uint16_t(in1.real())]) << 24) | - (item32_t(_table[boost::uint16_t(in1.imag())]) << 16) ; + (item32_t(_table[boost::uint16_t(in1.real())]) << 8) | + (item32_t(_table[boost::uint16_t(in1.imag())]) << 0) | + (item32_t(_table[boost::uint16_t(in0.real())]) << 24) | + (item32_t(_table[boost::uint16_t(in0.imag())]) << 16) ; } private: @@ -196,27 +196,27 @@ static converter::sptr make_convert_sc16_item32_le_1_to_fc64_1(void){ } static converter::sptr make_convert_sc8_item32_be_1_to_fc32_1(void){ - return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); + return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); } static converter::sptr make_convert_sc8_item32_be_1_to_fc64_1(void){ - return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); + return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); } static converter::sptr make_convert_sc8_item32_le_1_to_fc32_1(void){ - return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); + return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); } static converter::sptr make_convert_sc8_item32_le_1_to_fc64_1(void){ - return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); + return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); } static converter::sptr make_convert_sc8_item32_be_1_to_sc16_1(void){ - return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); + return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); } static converter::sptr make_convert_sc8_item32_le_1_to_sc16_1(void){ - return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); + return converter::sptr(new convert_sc8_item32_1_to_fcxx_1()); } static converter::sptr make_convert_sc16_1_to_sc8_item32_be_1(void){ diff --git a/host/lib/convert/sse2_fc32_to_sc8.cpp b/host/lib/convert/sse2_fc32_to_sc8.cpp index dd884640d..36aa68b0e 100644 --- a/host/lib/convert/sse2_fc32_to_sc8.cpp +++ b/host/lib/convert/sse2_fc32_to_sc8.cpp @@ -1,5 +1,5 @@ // -// Copyright 2012 Ettus Research LLC +// Copyright 2012-2013 Ettus Research LLC // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by @@ -47,7 +47,7 @@ DECLARE_CONVERTER(fc32, 1, sc8_item32_be, 1, PRIORITY_SIMD){ item32_t *output = reinterpret_cast(outputs[0]); const __m128 scalar = _mm_set_ps1(float(scale_factor)); - const int shuf = _MM_SHUFFLE(1, 0, 3, 2); + const int shuf = _MM_SHUFFLE(3, 2, 1, 0); #define convert_fc32_1_to_sc8_item32_1_bswap_guts(_al_) \ for (size_t j = 0; i+7 < nsamps; i+=8, j+=4){ \ @@ -83,7 +83,7 @@ DECLARE_CONVERTER(fc32, 1, sc8_item32_le, 1, PRIORITY_SIMD){ item32_t *output = reinterpret_cast(outputs[0]); const __m128 scalar = _mm_set_ps1(float(scale_factor)); - const int shuf = _MM_SHUFFLE(2, 3, 0, 1); + const int shuf = _MM_SHUFFLE(0, 1, 2, 3); #define convert_fc32_1_to_sc8_item32_1_nswap_guts(_al_) \ for (size_t j = 0; i+7 < nsamps; i+=8, j+=4){ \ diff --git a/host/lib/convert/sse2_fc64_to_sc8.cpp b/host/lib/convert/sse2_fc64_to_sc8.cpp index bf3719e13..82a8e0bb0 100644 --- a/host/lib/convert/sse2_fc64_to_sc8.cpp +++ b/host/lib/convert/sse2_fc64_to_sc8.cpp @@ -1,5 +1,5 @@ // -// Copyright 2012 Ettus Research LLC +// Copyright 2012-2013 Ettus Research LLC // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by @@ -59,10 +59,10 @@ DECLARE_CONVERTER(fc64, 1, sc8_item32_be, 1, PRIORITY_SIMD){ \ /* interleave */ \ const __m128i tmpi = pack_sc8_item32_4x( \ - pack_sc32_4x(tmp0, tmp1, scalar), \ - pack_sc32_4x(tmp2, tmp3, scalar), \ - pack_sc32_4x(tmp4, tmp5, scalar), \ - pack_sc32_4x(tmp6, tmp7, scalar) \ + pack_sc32_4x(tmp1, tmp0, scalar), \ + pack_sc32_4x(tmp3, tmp2, scalar), \ + pack_sc32_4x(tmp5, tmp4, scalar), \ + pack_sc32_4x(tmp7, tmp6, scalar) \ ); \ \ /* store to output */ \ @@ -103,10 +103,10 @@ DECLARE_CONVERTER(fc64, 1, sc8_item32_le, 1, PRIORITY_SIMD){ \ /* interleave */ \ __m128i tmpi = pack_sc8_item32_4x( \ - pack_sc32_4x(tmp1, tmp0, scalar), \ - pack_sc32_4x(tmp3, tmp2, scalar), \ - pack_sc32_4x(tmp5, tmp4, scalar), \ - pack_sc32_4x(tmp7, tmp6, scalar) \ + pack_sc32_4x(tmp0, tmp1, scalar), \ + pack_sc32_4x(tmp2, tmp3, scalar), \ + pack_sc32_4x(tmp4, tmp5, scalar), \ + pack_sc32_4x(tmp6, tmp7, scalar) \ ); \ tmpi = _mm_or_si128(_mm_srli_epi16(tmpi, 8), _mm_slli_epi16(tmpi, 8)); /*byteswap*/\ \ diff --git a/host/lib/convert/sse2_sc8_to_fc32.cpp b/host/lib/convert/sse2_sc8_to_fc32.cpp index c0e561814..724af0225 100644 --- a/host/lib/convert/sse2_sc8_to_fc32.cpp +++ b/host/lib/convert/sse2_sc8_to_fc32.cpp @@ -1,5 +1,5 @@ // -// Copyright 2012 Ettus Research LLC +// Copyright 2012-2013 Ettus Research LLC // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by @@ -48,7 +48,7 @@ DECLARE_CONVERTER(sc8_item32_be, 1, fc32, 1, PRIORITY_SIMD){ fc32_t *output = reinterpret_cast(outputs[0]); const __m128 scalar = _mm_set_ps1(float(scale_factor)/(1 << 24)); - const int shuf = _MM_SHUFFLE(1, 0, 3, 2); + const int shuf = _MM_SHUFFLE(3, 2, 1, 0); size_t i = 0, j = 0; fc32_t dummy; @@ -92,7 +92,7 @@ DECLARE_CONVERTER(sc8_item32_le, 1, fc32, 1, PRIORITY_SIMD){ fc32_t *output = reinterpret_cast(outputs[0]); const __m128 scalar = _mm_set_ps1(float(scale_factor)/(1 << 24)); - const int shuf = _MM_SHUFFLE(2, 3, 0, 1); + const int shuf = _MM_SHUFFLE(0, 1, 2, 3); size_t i = 0, j = 0; fc32_t dummy; diff --git a/host/lib/convert/sse2_sc8_to_fc64.cpp b/host/lib/convert/sse2_sc8_to_fc64.cpp index ef9c0fdb4..94d8911f6 100644 --- a/host/lib/convert/sse2_sc8_to_fc64.cpp +++ b/host/lib/convert/sse2_sc8_to_fc64.cpp @@ -1,5 +1,5 @@ // -// Copyright 2012 Ettus Research LLC +// Copyright 2012-2013 Ettus Research LLC // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by @@ -77,7 +77,7 @@ DECLARE_CONVERTER(sc8_item32_be, 1, fc64, 1, PRIORITY_SIMD){ \ /* unpack */ \ __m128d tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; \ - unpack_sc32_8x(tmpi, tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, scalar); \ + unpack_sc32_8x(tmpi, tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, scalar); \ \ /* store to output */ \ _mm_store ## _al_ ## pd(reinterpret_cast(output+j+0), tmp0); \ @@ -125,7 +125,7 @@ DECLARE_CONVERTER(sc8_item32_le, 1, fc64, 1, PRIORITY_SIMD){ /* unpack */ \ __m128d tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; \ tmpi = _mm_or_si128(_mm_srli_epi16(tmpi, 8), _mm_slli_epi16(tmpi, 8)); /*byteswap*/\ - unpack_sc32_8x(tmpi, tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, scalar); \ + unpack_sc32_8x(tmpi, tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, scalar); \ \ /* store to output */ \ _mm_store ## _al_ ## pd(reinterpret_cast(output+j+0), tmp0); \ -- cgit v1.2.3 From 2d4c77489f540a6978497d25dd3e316a2f16e9ad Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Wed, 28 Aug 2013 17:07:36 -0700 Subject: convert: added sc12 and fc32 converters --- host/lib/convert/CMakeLists.txt | 5 +- host/lib/convert/convert_fc32_item32.cpp | 113 +++++++++++++++++++++++ host/lib/convert/convert_pack_sc12.cpp | 144 +++++++++++++++++++++++++++++ host/lib/convert/convert_unpack_sc12.cpp | 152 +++++++++++++++++++++++++++++++ 4 files changed, 413 insertions(+), 1 deletion(-) create mode 100644 host/lib/convert/convert_fc32_item32.cpp create mode 100644 host/lib/convert/convert_pack_sc12.cpp create mode 100644 host/lib/convert/convert_unpack_sc12.cpp (limited to 'host') diff --git a/host/lib/convert/CMakeLists.txt b/host/lib/convert/CMakeLists.txt index 28defa8bc..00e129b78 100644 --- a/host/lib/convert/CMakeLists.txt +++ b/host/lib/convert/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright 2011-2012 Ettus Research LLC +# Copyright 2011-2013 Ettus Research LLC # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -121,4 +121,7 @@ LIBUHD_APPEND_SOURCES( ${CMAKE_CURRENT_SOURCE_DIR}/convert_with_tables.cpp ${CMAKE_CURRENT_SOURCE_DIR}/convert_impl.cpp ${CMAKE_CURRENT_SOURCE_DIR}/convert_item32.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/convert_pack_sc12.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/convert_unpack_sc12.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/convert_fc32_item32.cpp ) diff --git a/host/lib/convert/convert_fc32_item32.cpp b/host/lib/convert/convert_fc32_item32.cpp new file mode 100644 index 000000000..29bfefd46 --- /dev/null +++ b/host/lib/convert/convert_fc32_item32.cpp @@ -0,0 +1,113 @@ +// +// Copyright 2013 Ettus Research LLC +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// + +#include "convert_common.hpp" +#include +#include +#include +#include + +using namespace uhd::convert; + +typedef boost::uint32_t (*to32_type)(boost::uint32_t); + +template +struct convert_fc32_item32_1_to_star_1 : public converter +{ + convert_fc32_item32_1_to_star_1(void) + { + //NOP + } + + void set_scalar(const double scalar) + { + _scalar = scalar; + } + + void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps) + { + const item32_t *input = reinterpret_cast(inputs[0]); + std::complex *output = reinterpret_cast *>(outputs[0]); + + size_t i = 0; + for (size_t o = 0; o < nsamps; o++) + { + const item32_t i32 = tohost(input[i++]); + const item32_t q32 = tohost(input[i++]); + const float i_f32 = reinterpret_cast(i32); + const float q_f32 = reinterpret_cast(q32); + output[o] = std::complex(type(i_f32*_scalar), type(q_f32*_scalar)); + } + } + + double _scalar; +}; + +template +struct convert_star_1_to_fc32_item32_1 : public converter +{ + convert_star_1_to_fc32_item32_1(void) + { + //NOP + } + + void set_scalar(const double scalar) + { + _scalar = scalar; + } + + void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps) + { + const std::complex *input = reinterpret_cast *>(inputs[0]); + item32_t *output = reinterpret_cast(outputs[0]); + + size_t o = 0; + for (size_t i = 0; i < nsamps; i++) + { + const float i_f32 = type(input[i].real()*_scalar); + const float q_f32 = type(input[i].imag()*_scalar); + const item32_t i32 = towire(reinterpret_cast(i_f32)); + const item32_t q32 = towire(reinterpret_cast(q_f32)); + output[o++] = i32; output[o++] = q32; + } + } + + double _scalar; +}; + +#define __make_registrations(itype, otype, fcn, type, conv) \ +static converter::sptr make_convert_ ## itype ## _1_ ## otype ## _1(void) \ +{ \ + return converter::sptr(new fcn()); \ +} \ +UHD_STATIC_BLOCK(register_convert_ ## itype ## _1_ ## otype ## _1) \ +{ \ + uhd::convert::id_type id; \ + id.num_inputs = 1; id.num_outputs = 1; \ + id.input_format = #itype; id.output_format = #otype; \ + uhd::convert::register_converter(id, &make_convert_ ## itype ## _1_ ## otype ## _1, PRIORITY_GENERAL); \ +} + +__make_registrations(fc32_item32_le, fc32, convert_fc32_item32_1_to_star_1, float, uhd::wtohx) +__make_registrations(fc32_item32_be, fc32, convert_fc32_item32_1_to_star_1, float, uhd::ntohx) +__make_registrations(fc32_item32_le, fc64, convert_fc32_item32_1_to_star_1, double, uhd::wtohx) +__make_registrations(fc32_item32_be, fc64, convert_fc32_item32_1_to_star_1, double, uhd::ntohx) + +__make_registrations(fc32, fc32_item32_le, convert_star_1_to_fc32_item32_1, float, uhd::wtohx) +__make_registrations(fc32, fc32_item32_be, convert_star_1_to_fc32_item32_1, float, uhd::ntohx) +__make_registrations(fc64, fc32_item32_le, convert_star_1_to_fc32_item32_1, double, uhd::wtohx) +__make_registrations(fc64, fc32_item32_be, convert_star_1_to_fc32_item32_1, double, uhd::ntohx) diff --git a/host/lib/convert/convert_pack_sc12.cpp b/host/lib/convert/convert_pack_sc12.cpp new file mode 100644 index 000000000..680814994 --- /dev/null +++ b/host/lib/convert/convert_pack_sc12.cpp @@ -0,0 +1,144 @@ +// +// Copyright 2013 Ettus Research LLC +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// + +#include "convert_common.hpp" +#include +#include +#include +#include + +using namespace uhd::convert; + +typedef boost::uint32_t (*towire32_type)(boost::uint32_t); + +struct item32_sc12_3x +{ + item32_t line0; + item32_t line1; + item32_t line2; +}; + +template +void convert_star_4_to_sc12_item32_3 +( + const std::complex &in0, + const std::complex &in1, + const std::complex &in2, + const std::complex &in3, + item32_sc12_3x &output, + const double scalar +) +{ + const item32_t i0 = boost::int32_t(type(in0.real()*scalar)) & 0xfff; + const item32_t q0 = boost::int32_t(type(in0.imag()*scalar)) & 0xfff; + + const item32_t i1 = boost::int32_t(type(in1.real()*scalar)) & 0xfff; + const item32_t q1 = boost::int32_t(type(in1.imag()*scalar)) & 0xfff; + + const item32_t i2 = boost::int32_t(type(in2.real()*scalar)) & 0xfff; + const item32_t q2 = boost::int32_t(type(in2.imag()*scalar)) & 0xfff; + + const item32_t i3 = boost::int32_t(type(in3.real()*scalar)) & 0xfff; + const item32_t q3 = boost::int32_t(type(in3.imag()*scalar)) & 0xfff; + + const item32_t line0 = (i0 << 20) | (q0 << 8) | (i1 >> 4); + const item32_t line1 = (i1 << 28) | (q1 << 16) | (i2 << 4) | (q2 >> 8); + const item32_t line2 = (q2 << 24) | (i3 << 12) | (q3); + + output.line0 = towire(line0); + output.line1 = towire(line1); + output.line2 = towire(line2); +} + +template +struct convert_star_1_to_sc12_item32_1 : public converter +{ + convert_star_1_to_sc12_item32_1(void) + { + //NOP + } + + void set_scalar(const double scalar) + { + _scalar = scalar; + } + + void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps) + { + const std::complex *input = reinterpret_cast *>(inputs[0]); + item32_sc12_3x *output = reinterpret_cast(size_t(outputs[0]) & ~0x3); + + //helper variables + size_t i = 0, o = 0; + + //handle the head case + const size_t head_samps = size_t(outputs[0]) & 0x3; + switch (head_samps) + { + case 0: break; //no head + case 1: convert_star_4_to_sc12_item32_3(0, 0, 0, input[0], output[o++], _scalar); break; + case 2: convert_star_4_to_sc12_item32_3(0, 0, input[0], input[1], output[o++], _scalar); break; + case 3: convert_star_4_to_sc12_item32_3(0, input[0], input[1], input[2], output[o++], _scalar); break; + } + i += head_samps; + + //convert the body + while (i+3 < nsamps) + { + convert_star_4_to_sc12_item32_3(input[i+0], input[i+1], input[i+2], input[i+3], output[o], _scalar); + o++; i += 4; + } + + //handle the tail case + const size_t tail_samps = nsamps - i; + switch (tail_samps) + { + case 0: break; //no tail + case 1: convert_star_4_to_sc12_item32_3(input[i+0], 0, 0, 0, output[o], _scalar); break; + case 2: convert_star_4_to_sc12_item32_3(input[i+0], input[i+1], 0, 0, output[o], _scalar); break; + case 3: convert_star_4_to_sc12_item32_3(input[i+0], input[i+1], input[i+2], 0, output[o], _scalar); break; + } + } + + double _scalar; +}; + +static converter::sptr make_convert_fc32_1_to_sc12_item32_le_1(void) +{ + return converter::sptr(new convert_star_1_to_sc12_item32_1()); +} + +static converter::sptr make_convert_fc32_1_to_sc12_item32_be_1(void) +{ + return converter::sptr(new convert_star_1_to_sc12_item32_1()); +} + +UHD_STATIC_BLOCK(register_convert_pack_sc12) +{ + //uhd::convert::register_bytes_per_item("sc12", 3/*bytes*/); //registered in unpack + + uhd::convert::id_type id; + id.num_inputs = 1; + id.num_outputs = 1; + id.input_format = "fc32"; + + id.output_format = "sc12_item32_le"; + uhd::convert::register_converter(id, &make_convert_fc32_1_to_sc12_item32_le_1, PRIORITY_GENERAL); + + id.output_format = "sc12_item32_be"; + uhd::convert::register_converter(id, &make_convert_fc32_1_to_sc12_item32_be_1, PRIORITY_GENERAL); +} diff --git a/host/lib/convert/convert_unpack_sc12.cpp b/host/lib/convert/convert_unpack_sc12.cpp new file mode 100644 index 000000000..f578b6c95 --- /dev/null +++ b/host/lib/convert/convert_unpack_sc12.cpp @@ -0,0 +1,152 @@ +// +// Copyright 2013 Ettus Research LLC +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// + +#include "convert_common.hpp" +#include +#include +#include +#include + +using namespace uhd::convert; + +typedef boost::uint32_t (*tohost32_type)(boost::uint32_t); + +struct item32_sc12_3x +{ + item32_t line0; + item32_t line1; + item32_t line2; +}; + +template +void convert_sc12_item32_3_to_star_4 +( + const item32_sc12_3x &input, + std::complex &out0, + std::complex &out1, + std::complex &out2, + std::complex &out3, + const double scalar +) +{ + //step 0: extract the lines from the input buffer + const item32_t line0 = tohost(input.line0); + const item32_t line1 = tohost(input.line1); + const item32_t line2 = tohost(input.line2); + const boost::uint64_t line01 = (boost::uint64_t(line0) << 32) | line1; + const boost::uint64_t line12 = (boost::uint64_t(line1) << 32) | line2; + + //step 1: shift out and mask off the individual numbers + const type i0 = type(boost::int16_t(line0 >> 16)*scalar); + const type q0 = type(boost::int16_t(line0 >> 4)*scalar); + + const type i1 = type(boost::int16_t(line01 >> 24)*scalar); + const type q1 = type(boost::int16_t(line1 >> 12)*scalar); + + const type i2 = type(boost::int16_t(line1 >> 0)*scalar); + const type q2 = type(boost::int16_t(line12 >> 20)*scalar); + + const type i3 = type(boost::int16_t(line2 >> 8)*scalar); + const type q3 = type(boost::int16_t(line2 << 4)*scalar); + + //step 2: load the outputs + out0 = std::complex(i0, q0); + out1 = std::complex(i1, q1); + out2 = std::complex(i2, q2); + out3 = std::complex(i3, q3); +} + +template +struct convert_sc12_item32_1_to_star_1 : public converter +{ + convert_sc12_item32_1_to_star_1(void) + { + //NOP + } + + void set_scalar(const double scalar) + { + const int unpack_growth = 16; + _scalar = scalar/unpack_growth; + } + + void operator()(const input_type &inputs, const output_type &outputs, const size_t nsamps) + { + const item32_sc12_3x *input = reinterpret_cast(size_t(inputs[0]) & ~0x3); + std::complex *output = reinterpret_cast *>(outputs[0]); + + //helper variables + std::complex dummy0, dummy1, dummy2; + size_t i = 0, o = 0; + + //handle the head case + const size_t head_samps = size_t(inputs[0]) & 0x3; + switch (head_samps) + { + case 0: break; //no head + case 1: convert_sc12_item32_3_to_star_4(input[i++], dummy0, dummy1, dummy2, output[0], _scalar); break; + case 2: convert_sc12_item32_3_to_star_4(input[i++], dummy0, dummy1, output[0], output[1], _scalar); break; + case 3: convert_sc12_item32_3_to_star_4(input[i++], dummy0, output[0], output[1], output[2], _scalar); break; + } + o += head_samps; + + //convert the body + while (o+3 < nsamps) + { + convert_sc12_item32_3_to_star_4(input[i], output[o+0], output[o+1], output[o+2], output[o+3], _scalar); + i++; o += 4; + } + + //handle the tail case + const size_t tail_samps = nsamps - o; + switch (tail_samps) + { + case 0: break; //no tail + case 1: convert_sc12_item32_3_to_star_4(input[i], output[o+0], dummy0, dummy1, dummy2, _scalar); break; + case 2: convert_sc12_item32_3_to_star_4(input[i], output[o+0], output[o+1], dummy1, dummy2, _scalar); break; + case 3: convert_sc12_item32_3_to_star_4(input[i], output[o+0], output[o+1], output[o+2], dummy2, _scalar); break; + } + } + + double _scalar; +}; + +static converter::sptr make_convert_sc12_item32_le_1_to_fc32_1(void) +{ + return converter::sptr(new convert_sc12_item32_1_to_star_1()); +} + +static converter::sptr make_convert_sc12_item32_be_1_to_fc32_1(void) +{ + return converter::sptr(new convert_sc12_item32_1_to_star_1()); +} + +UHD_STATIC_BLOCK(register_convert_unpack_sc12) +{ + uhd::convert::register_bytes_per_item("sc12", 3/*bytes*/); + + uhd::convert::id_type id; + id.num_inputs = 1; + id.num_outputs = 1; + id.output_format = "fc32"; + + id.input_format = "sc12_item32_le"; + uhd::convert::register_converter(id, &make_convert_sc12_item32_le_1_to_fc32_1, PRIORITY_GENERAL); + + id.input_format = "sc12_item32_be"; + uhd::convert::register_converter(id, &make_convert_sc12_item32_be_1_to_fc32_1, PRIORITY_GENERAL); +} -- cgit v1.2.3 From 3e6c6a92087f551e2047e383f4e600feca5b3e32 Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Wed, 4 Sep 2013 11:09:47 -0700 Subject: vita: changed CHDR format to use bytes --- host/lib/transport/gen_vrt_if_packet.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) (limited to 'host') diff --git a/host/lib/transport/gen_vrt_if_packet.py b/host/lib/transport/gen_vrt_if_packet.py index 56e7c61bf..98f6804ae 100644 --- a/host/lib/transport/gen_vrt_if_packet.py +++ b/host/lib/transport/gen_vrt_if_packet.py @@ -79,24 +79,26 @@ static const size_t occ_table[] = {0, 2, 1, 3}; const boost::uint32_t VRLP = ('V' << 24) | ('R' << 16) | ('L' << 8) | ('P' << 0); const boost::uint32_t VEND = ('V' << 24) | ('E' << 16) | ('N' << 8) | ('D' << 0); -UHD_INLINE static boost::uint32_t chdr_to_vrt(const boost::uint32_t chdr, size_t &packet_count) +UHD_INLINE static boost::uint32_t chdr_to_vrt(const boost::uint32_t chdr, if_packet_info_t &info) { - boost::uint32_t vrt = chdr & 0xffff; //words32 - packet_count = (chdr >> 16) & 0xfff; + const boost::uint32_t bytes = chdr & 0xffff; + boost::uint32_t vrt = (bytes + 3)/4; + info.packet_count = (chdr >> 16) & 0xfff; vrt |= ((chdr >> 31) & 0x1) << 30; //context packet - vrt |= ((chdr >> 30) & 0x1) << 26; //has tlr vrt |= ((chdr >> 29) & 0x1) << 20; //has tsf vrt |= ((chdr >> 28) & 0x1) << 24; //has eob vrt |= (0x1) << 28; //has sid (always) return vrt; } -UHD_INLINE static boost::uint32_t vrt_to_chdr(const boost::uint32_t vrt, const size_t packet_count) +UHD_INLINE static boost::uint32_t vrt_to_chdr(const boost::uint32_t vrt, const if_packet_info_t &info) { - boost::uint32_t chdr = vrt & 0xffff; //words32 - chdr |= (packet_count & 0xfff) << 16; + const boost::uint32_t words32 = vrt & 0xffff; + int bytes_rem = info.num_payload_bytes % 4; + if (bytes_rem != 0) bytes_rem -= 4; //adjust for round up + boost::uint32_t chdr = (words32 * 4) + bytes_rem; + chdr |= (info.packet_count & 0xfff) << 16; chdr |= ((vrt >> 30) & 0x1) << 31; //context packet - chdr |= ((vrt >> 26) & 0x1) << 30; //has tlr chdr |= ((vrt >> 20) & 0x1) << 29; //has tsf chdr |= ((vrt >> 24) & 0x1) << 28; //has eob return chdr; @@ -311,7 +313,7 @@ void vrt::if_hdr_pack_$(suffix)( case if_packet_info_t::LINK_TYPE_CHDR: { __if_hdr_pack_$(suffix)(packet_buff, if_packet_info, vrt_hdr_word32); - const boost::uint32_t chdr = vrt_to_chdr(vrt_hdr_word32, if_packet_info.packet_count); + const boost::uint32_t chdr = vrt_to_chdr(vrt_hdr_word32, if_packet_info); packet_buff[0] = $(XE_MACRO)(chdr); break; } @@ -349,9 +351,10 @@ void vrt::if_hdr_unpack_$(suffix)( case if_packet_info_t::LINK_TYPE_CHDR: { const boost::uint32_t chdr = $(XE_MACRO)(packet_buff[0]); - size_t packet_count = 0; - vrt_hdr_word32 = chdr_to_vrt(chdr, packet_count); + vrt_hdr_word32 = chdr_to_vrt(chdr, if_packet_info); + size_t packet_count = if_packet_info.packet_count; __if_hdr_unpack_$(suffix)(packet_buff, if_packet_info, vrt_hdr_word32); + if_packet_info.num_payload_bytes -= (~chdr + 1) & 0x3; if_packet_info.packet_count = packet_count; break; } -- cgit v1.2.3 From 0284b5fb03608202f02897bf1a86307cb4a4f69b Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Wed, 4 Sep 2013 11:11:28 -0700 Subject: vita: switch modules to CHDR byte format --- host/lib/usrp/b200/b200_impl.cpp | 4 ++-- host/lib/usrp/cores/radio_ctrl_core_3000.cpp | 13 +++++++------ host/lib/usrp/cores/radio_ctrl_core_3000.hpp | 3 +-- 3 files changed, 10 insertions(+), 10 deletions(-) (limited to 'host') diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp index f7ed35e50..09c0d3979 100644 --- a/host/lib/usrp/b200/b200_impl.cpp +++ b/host/lib/usrp/b200/b200_impl.cpp @@ -252,7 +252,7 @@ b200_impl::b200_impl(const device_addr_t &device_addr) //////////////////////////////////////////////////////////////////// // Local control endpoint //////////////////////////////////////////////////////////////////// - _local_ctrl = radio_ctrl_core_3000::make(vrt::if_packet_info_t::LINK_TYPE_CHDR, _ctrl_transport, zero_copy_if::sptr()/*null*/, B200_LOCAL_CTRL_SID); + _local_ctrl = radio_ctrl_core_3000::make(false/*lilE*/, _ctrl_transport, zero_copy_if::sptr()/*null*/, B200_LOCAL_CTRL_SID); _local_ctrl->hold_task(_async_task); _async_task_data->local_ctrl = _local_ctrl; //weak this->check_fpga_compat(); @@ -488,7 +488,7 @@ void b200_impl::setup_radio(const size_t dspno) // radio control //////////////////////////////////////////////////////////////////// const boost::uint32_t sid = (dspno == 0)? B200_CTRL0_MSG_SID : B200_CTRL1_MSG_SID; - perif.ctrl = radio_ctrl_core_3000::make(vrt::if_packet_info_t::LINK_TYPE_CHDR, _ctrl_transport, zero_copy_if::sptr()/*null*/, sid); + perif.ctrl = radio_ctrl_core_3000::make(false/*lilE*/, _ctrl_transport, zero_copy_if::sptr()/*null*/, sid); perif.ctrl->hold_task(_async_task); _async_task_data->radio_ctrl[dspno] = perif.ctrl; //weak _tree->access(mb_path / "time" / "cmd") diff --git a/host/lib/usrp/cores/radio_ctrl_core_3000.cpp b/host/lib/usrp/cores/radio_ctrl_core_3000.cpp index 616903920..5298fd213 100644 --- a/host/lib/usrp/cores/radio_ctrl_core_3000.cpp +++ b/host/lib/usrp/cores/radio_ctrl_core_3000.cpp @@ -22,6 +22,7 @@ #include #include #include +#include #include #include #include @@ -32,7 +33,7 @@ using namespace uhd; using namespace uhd::usrp; using namespace uhd::transport; -static const double ACK_TIMEOUT = 0.5; +static const double ACK_TIMEOUT = 2.0; //supposed to be worst case practical timeout static const double MASSIVE_TIMEOUT = 10.0; //for when we wait on a timed command static const size_t SR_READBACK = 32; @@ -41,15 +42,15 @@ class radio_ctrl_core_3000_impl : public radio_ctrl_core_3000 public: radio_ctrl_core_3000_impl( - vrt::if_packet_info_t::link_type_t link_type, + const bool big_endian, uhd::transport::zero_copy_if::sptr ctrl_xport, uhd::transport::zero_copy_if::sptr resp_xport, const boost::uint32_t sid, const std::string &name ): - _link_type(link_type), + _link_type(vrt::if_packet_info_t::LINK_TYPE_CHDR), _packet_type(vrt::if_packet_info_t::PACKET_TYPE_CONTEXT), - _bige(link_type == vrt::if_packet_info_t::LINK_TYPE_VRLP), + _bige(big_endian), _ctrl_xport(ctrl_xport), _resp_xport(resp_xport), _sid(sid), @@ -301,12 +302,12 @@ private: radio_ctrl_core_3000::sptr radio_ctrl_core_3000::make( - vrt::if_packet_info_t::link_type_t link_type, + const bool big_endian, zero_copy_if::sptr ctrl_xport, zero_copy_if::sptr resp_xport, const boost::uint32_t sid, const std::string &name ) { - return sptr(new radio_ctrl_core_3000_impl(link_type, ctrl_xport, resp_xport, sid, name)); + return sptr(new radio_ctrl_core_3000_impl(big_endian, ctrl_xport, resp_xport, sid, name)); } diff --git a/host/lib/usrp/cores/radio_ctrl_core_3000.hpp b/host/lib/usrp/cores/radio_ctrl_core_3000.hpp index 6ef484296..8c0548d89 100644 --- a/host/lib/usrp/cores/radio_ctrl_core_3000.hpp +++ b/host/lib/usrp/cores/radio_ctrl_core_3000.hpp @@ -20,7 +20,6 @@ #include #include -#include #include #include #include "wb_iface.hpp" @@ -36,7 +35,7 @@ public: //! Make a new control object static sptr make( - uhd::transport::vrt::if_packet_info_t::link_type_t link_type, + const bool big_endian, uhd::transport::zero_copy_if::sptr ctrl_xport, uhd::transport::zero_copy_if::sptr resp_xport, const boost::uint32_t sid, -- cgit v1.2.3 From 8c1b63e1949134ec476b5b43e1caca42ffe017d5 Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Wed, 4 Sep 2013 11:11:50 -0700 Subject: b200: integrate support for new converters --- host/CMakeLists.txt | 2 +- host/lib/usrp/b200/b200_io_impl.cpp | 22 +++++++++++----------- host/lib/usrp/b200/b200_regs.hpp | 2 ++ host/lib/usrp/cores/rx_dsp_core_3000.cpp | 17 +++++++++++------ host/lib/usrp/cores/tx_dsp_core_3000.cpp | 15 ++++++++++----- 5 files changed, 35 insertions(+), 23 deletions(-) (limited to 'host') diff --git a/host/CMakeLists.txt b/host/CMakeLists.txt index d6851156a..9630240cf 100644 --- a/host/CMakeLists.txt +++ b/host/CMakeLists.txt @@ -110,7 +110,7 @@ IF(MSVC) -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE ) - ADD_DEFINITIONS(/MP) + ADD_DEFINITIONS(/MP) #multi-threaded build ENDIF(MSVC) IF(CYGWIN) diff --git a/host/lib/usrp/b200/b200_io_impl.cpp b/host/lib/usrp/b200/b200_io_impl.cpp index 5a588f902..d643ef855 100644 --- a/host/lib/usrp/b200/b200_io_impl.cpp +++ b/host/lib/usrp/b200/b200_io_impl.cpp @@ -214,11 +214,7 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t &args_) stream_args_t args = args_; //setup defaults for unspecified values - if (not args.otw_format.empty() and args.otw_format != "sc16") - { - throw uhd::value_error("b200_impl::get_rx_stream only supports otw_format sc16"); - } - args.otw_format = "sc16"; + if (args.otw_format.empty()) args.otw_format = "sc16"; args.channels = args.channels.empty()? std::vector(1, 0) : args.channels; boost::shared_ptr my_streamer; @@ -226,6 +222,10 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t &args_) { const size_t chan = args.channels[stream_i]; radio_perifs_t &perif = _radio_perifs[chan]; + if (args.otw_format == "sc16") perif.ctrl->poke32(TOREG(SR_RX_FMT), 0); + if (args.otw_format == "sc12") perif.ctrl->poke32(TOREG(SR_RX_FMT), 1); + if (args.otw_format == "fc32") perif.ctrl->poke32(TOREG(SR_RX_FMT), 2); + if (args.otw_format == "sc8") perif.ctrl->poke32(TOREG(SR_RX_FMT), 3); const boost::uint32_t sid = chan?B200_RX_DATA1_SID:B200_RX_DATA0_SID; //calculate packet size @@ -238,7 +238,7 @@ rx_streamer::sptr b200_impl::get_rx_stream(const uhd::stream_args_t &args_) const size_t bpp = _data_transport->get_recv_frame_size() - hdr_size; const size_t bpi = convert::get_bytes_per_item(args.otw_format); size_t spp = unsigned(args.args.cast("spp", bpp/bpi)); - spp = std::min(2041, spp); //magic maximum for framing at full rate + spp = std::min(2000, spp); //magic maximum for framing at full rate //make the new streamer given the samples per packet if (not my_streamer) my_streamer = boost::make_shared(spp); @@ -316,11 +316,7 @@ tx_streamer::sptr b200_impl::get_tx_stream(const uhd::stream_args_t &args_) stream_args_t args = args_; //setup defaults for unspecified values - if (not args.otw_format.empty() and args.otw_format != "sc16") - { - throw uhd::value_error("b200_impl::get_rx_stream only supports otw_format sc16"); - } - args.otw_format = "sc16"; + if (args.otw_format.empty()) args.otw_format = "sc16"; args.channels = args.channels.empty()? std::vector(1, 0) : args.channels; boost::shared_ptr my_streamer; @@ -328,6 +324,10 @@ tx_streamer::sptr b200_impl::get_tx_stream(const uhd::stream_args_t &args_) { const size_t chan = args.channels[stream_i]; radio_perifs_t &perif = _radio_perifs[chan]; + if (args.otw_format == "sc16") perif.ctrl->poke32(TOREG(SR_TX_FMT), 0); + if (args.otw_format == "sc12") perif.ctrl->poke32(TOREG(SR_TX_FMT), 1); + if (args.otw_format == "fc32") perif.ctrl->poke32(TOREG(SR_TX_FMT), 2); + if (args.otw_format == "sc8") perif.ctrl->poke32(TOREG(SR_TX_FMT), 3); //calculate packet size static const size_t hdr_size = 0 diff --git a/host/lib/usrp/b200/b200_regs.hpp b/host/lib/usrp/b200/b200_regs.hpp index ae39b95b2..c64066b27 100644 --- a/host/lib/usrp/b200/b200_regs.hpp +++ b/host/lib/usrp/b200/b200_regs.hpp @@ -43,6 +43,8 @@ localparam SR_RX_CTRL = 96; localparam SR_RX_DSP = 144; localparam SR_TX_DSP = 184; localparam SR_TIME = 128; +localparam SR_RX_FMT = 136; +localparam SR_TX_FMT = 138; localparam RB32_TEST = 0; localparam RB64_TIME_NOW = 8; diff --git a/host/lib/usrp/cores/rx_dsp_core_3000.cpp b/host/lib/usrp/cores/rx_dsp_core_3000.cpp index 36d9af5bc..7b3324f74 100644 --- a/host/lib/usrp/cores/rx_dsp_core_3000.cpp +++ b/host/lib/usrp/cores/rx_dsp_core_3000.cpp @@ -169,21 +169,26 @@ public: void setup(const uhd::stream_args_t &stream_args){ - //unsigned format_word = 0; if (stream_args.otw_format == "sc16"){ - //format_word = 0; _dsp_extra_scaling = 1.0; _host_extra_scaling = 1.0; } - /* else if (stream_args.otw_format == "sc8"){ - format_word = (1 << 0); double peak = stream_args.args.cast("peak", 1.0); peak = std::max(peak, 1.0/256); _host_extra_scaling = peak*256; - _dsp_extra_scaling = peak*256; + _dsp_extra_scaling = peak; + } + else if (stream_args.otw_format == "sc12"){ + double peak = stream_args.args.cast("peak", 1.0); + peak = std::max(peak, 1.0/16); + _host_extra_scaling = peak*16; + _dsp_extra_scaling = peak; + } + else if (stream_args.otw_format == "fc32"){ + _host_extra_scaling = 1.0; + _dsp_extra_scaling = 1.0; } - */ else throw uhd::value_error("USRP RX cannot handle requested wire format: " + stream_args.otw_format); _host_extra_scaling *= stream_args.args.cast("fullscale", 1.0); diff --git a/host/lib/usrp/cores/tx_dsp_core_3000.cpp b/host/lib/usrp/cores/tx_dsp_core_3000.cpp index ff4392a13..feb749cd9 100644 --- a/host/lib/usrp/cores/tx_dsp_core_3000.cpp +++ b/host/lib/usrp/cores/tx_dsp_core_3000.cpp @@ -146,22 +146,27 @@ public: void setup(const uhd::stream_args_t &stream_args){ - //unsigned format_word = 0; if (stream_args.otw_format == "sc16"){ - //format_word = 0; _dsp_extra_scaling = 1.0; _host_extra_scaling = 1.0; } - /* else if (stream_args.otw_format == "sc8"){ - format_word = (1 << 0); double peak = stream_args.args.cast("peak", 1.0); peak = std::max(peak, 1.0/256); _host_extra_scaling = 1.0/peak/256; _dsp_extra_scaling = 1.0/peak; } + else if (stream_args.otw_format == "sc12"){ + double peak = stream_args.args.cast("peak", 1.0); + peak = std::max(peak, 1.0/16); + _host_extra_scaling = 1.0/peak/16; + _dsp_extra_scaling = 1.0/peak; + } + else if (stream_args.otw_format == "fc32"){ + _host_extra_scaling = 1.0; + _dsp_extra_scaling = 1.0; + } else throw uhd::value_error("USRP TX cannot handle requested wire format: " + stream_args.otw_format); - */ _host_extra_scaling /= stream_args.args.cast("fullscale", 1.0); -- cgit v1.2.3