usrp_lib.cpp 48.6 KB
Newer Older
1 2 3 4 5
/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
6
 * the OAI Public License, Version 1.1  (the "License"); you may not use this file
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 * except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.openairinterface.org/?page_id=698
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */

Raymond Knopp's avatar
 
Raymond Knopp committed
22 23
/** usrp_lib.cpp
 *
24
 * \author: HongliangXU : hong-liang-xu@agilent.com
Raymond Knopp's avatar
 
Raymond Knopp committed
25
 */
26 27
#define _LARGEFILE_SOURCE
#define _FILE_OFFSET_BITS 64
Raymond Knopp's avatar
 
Raymond Knopp committed
28 29 30 31
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
32 33
#include <uhd/version.hpp>
#if UHD_VERSION < 3110000
34
  #include <uhd/utils/thread_priority.hpp>
35
#else
36
  #include <uhd/utils/thread.hpp>
37
#endif
Raymond Knopp's avatar
 
Raymond Knopp committed
38
#include <uhd/usrp/multi_usrp.hpp>
39
#include <uhd/version.hpp>
Raymond Knopp's avatar
 
Raymond Knopp committed
40 41
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
Florian Kaltenberger's avatar
Florian Kaltenberger committed
42 43
#include <boost/thread.hpp>
#include <boost/format.hpp>
Raymond Knopp's avatar
 
Raymond Knopp committed
44 45 46 47
#include <iostream>
#include <complex>
#include <fstream>
#include <cmath>
48
#include <time.h>
49
#include "common/utils/LOG/log.h"
Raymond Knopp's avatar
 
Raymond Knopp committed
50
#include "common_lib.h"
laurent's avatar
laurent committed
51
#include "assertions.h"
52

WANG Tsu-Han's avatar
WANG Tsu-Han committed
53 54
#include "common/utils/LOG/vcd_signal_dumper.h"

bruno mongazon-cazavet's avatar
bruno mongazon-cazavet committed
55
#include <sys/resource.h>
laurent's avatar
laurent committed
56

57
#ifdef __SSE4_1__
58
  #include <smmintrin.h>
59
#endif
laurent's avatar
laurent committed
60

61
#ifdef __AVX2__
62
  #include <immintrin.h>
63
#endif
64

65
#ifdef __arm__
66
  #include <arm_neon.h>
67 68
#endif

69 70 71
/** @addtogroup _USRP_PHY_RF_INTERFACE_
 * @{
 */
Rakesh's avatar
Rakesh committed
72
int gpio789=0;
73 74
extern int usrp_tx_thread;

75

laurent's avatar
laurent committed
76
typedef struct {
Raymond Knopp's avatar
 
Raymond Knopp committed
77

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
  // --------------------------------
  // variables for USRP configuration
  // --------------------------------
  //! USRP device pointer
  uhd::usrp::multi_usrp::sptr usrp;

  //create a send streamer and a receive streamer
  //! USRP TX Stream
  uhd::tx_streamer::sptr tx_stream;
  //! USRP RX Stream
  uhd::rx_streamer::sptr rx_stream;

  //! USRP TX Metadata
  uhd::tx_metadata_t tx_md;
  //! USRP RX Metadata
  uhd::rx_metadata_t rx_md;

  //! Sampling rate
  double sample_rate;

  //! TX forward samples. We use usrp_time_offset to get this value
  int tx_forward_nsamps; //166 for 20Mhz

  // --------------------------------
  // Debug and output control
  // --------------------------------
  int num_underflows;
  int num_overflows;
  int num_seq_errors;
  int64_t tx_count;
  int64_t rx_count;
  int wait_for_first_pps;
  int use_gps;
111 112
  //int first_tx;
  //int first_rx;
113 114
  //! timestamp of RX packet
  openair0_timestamp rx_timestamp;
laurent's avatar
laurent committed
115
} usrp_state_t;
Raymond Knopp's avatar
 
Raymond Knopp committed
116

Florian Kaltenberger's avatar
Florian Kaltenberger committed
117 118
//void print_notes(void)
//{
119 120 121 122 123 124
// Helpful notes
//  std::cout << boost::format("**************************************Helpful Notes on Clock/PPS Selection**************************************\n");
//  std::cout << boost::format("As you can see, the default 10 MHz Reference and 1 PPS signals are now from the GPSDO.\n");
//  std::cout << boost::format("If you would like to use the internal reference(TCXO) in other applications, you must configure that explicitly.\n");
//  std::cout << boost::format("You can no longer select the external SMAs for 10 MHz or 1 PPS signaling.\n");
//  std::cout << boost::format("****************************************************************************************************************\n");
Florian Kaltenberger's avatar
Florian Kaltenberger committed
125 126
//}

127 128 129 130 131 132 133 134 135
int check_ref_locked(usrp_state_t *s,size_t mboard) {
  std::vector<std::string> sensor_names = s->usrp->get_mboard_sensor_names(mboard);
  bool ref_locked = false;

  if(std::find(sensor_names.begin(), sensor_names.end(), "ref_locked") != sensor_names.end()) {
    std::cout << "Waiting for reference lock..." << std::flush;

    for (int i = 0; i < 30 and not ref_locked; i++) {
      ref_locked = s->usrp->get_mboard_sensor("ref_locked", mboard).to_bool();
136

137
      if (not ref_locked) {
138 139
        std::cout << "." << std::flush;
        boost::this_thread::sleep(boost::posix_time::seconds(1));
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
      }
    }

    if(ref_locked) {
      std::cout << "LOCKED" << std::endl;
    } else {
      std::cout << "FAILED" << std::endl;
    }
  } else {
    std::cout << boost::format("ref_locked sensor not present on this board.\n");
  }

  return ref_locked;
}

155
static int sync_to_gps(openair0_device *device) {
Laurent OpenCells's avatar
Laurent OpenCells committed
156
  //uhd::set_thread_priority_safe();
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
  //std::string args;
  //Set up program options
  //po::options_description desc("Allowed options");
  //desc.add_options()
  //("help", "help message")
  //("args", po::value<std::string>(&args)->default_value(""), "USRP device arguments")
  //;
  //po::variables_map vm;
  //po::store(po::parse_command_line(argc, argv, desc), vm);
  //po::notify(vm);
  //Print the help message
  //if (vm.count("help"))
  //{
  //  std::cout << boost::format("Synchronize USRP to GPS %s") % desc << std::endl;
  // return EXIT_FAILURE;
  //}
  //Create a USRP device
  //std::cout << boost::format("\nCreating the USRP device with: %s...\n") % args;
  //uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);
  //std::cout << boost::format("Using Device: %s\n") % usrp->get_pp_string();
  usrp_state_t *s = (usrp_state_t *)device->priv;

  try {
    size_t num_mboards = s->usrp->get_num_mboards();
    size_t num_gps_locked = 0;

    for (size_t mboard = 0; mboard < num_mboards; mboard++) {
      std::cout << "Synchronizing mboard " << mboard << ": " << s->usrp->get_mboard_name(mboard) << std::endl;
185 186 187
      bool ref_locked = check_ref_locked(s,mboard);

      if (ref_locked) {
188
        std::cout << boost::format("Ref Locked\n");
189
      } else {
190 191
        std::cout << "Failed to lock to GPSDO 10 MHz Reference. Exiting." << std::endl;
        exit(EXIT_FAILURE);
192
      }
Florian Kaltenberger's avatar
Florian Kaltenberger committed
193

194 195
      //Wait for GPS lock
      bool gps_locked = s->usrp->get_mboard_sensor("gps_locked", mboard).to_bool();
Florian Kaltenberger's avatar
Florian Kaltenberger committed
196

197 198 199 200
      if(gps_locked) {
        num_gps_locked++;
        std::cout << boost::format("GPS Locked\n");
      } else {
201
        LOG_W(HW,"WARNING:  GPS not locked - time will not be accurate until locked\n");
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
      }

      //Set to GPS time
      uhd::time_spec_t gps_time = uhd::time_spec_t(time_t(s->usrp->get_mboard_sensor("gps_time", mboard).to_int()));
      //s->usrp->set_time_next_pps(gps_time+1.0, mboard);
      s->usrp->set_time_next_pps(uhd::time_spec_t(0.0));
      //Wait for it to apply
      //The wait is 2 seconds because N-Series has a known issue where
      //the time at the last PPS does not properly update at the PPS edge
      //when the time is actually set.
      boost::this_thread::sleep(boost::posix_time::seconds(2));
      //Check times
      gps_time = uhd::time_spec_t(time_t(s->usrp->get_mboard_sensor("gps_time", mboard).to_int()));
      uhd::time_spec_t time_last_pps = s->usrp->get_time_last_pps(mboard);
      std::cout << "USRP time: " << (boost::format("%0.9f") % time_last_pps.get_real_secs()) << std::endl;
      std::cout << "GPSDO time: " << (boost::format("%0.9f") % gps_time.get_real_secs()) << std::endl;
      //if (gps_time.get_real_secs() == time_last_pps.get_real_secs())
      //    std::cout << std::endl << "SUCCESS: USRP time synchronized to GPS time" << std::endl << std::endl;
      //else
      //    std::cerr << std::endl << "ERROR: Failed to synchronize USRP time to GPS time" << std::endl << std::endl;
Florian Kaltenberger's avatar
Florian Kaltenberger committed
222
    }
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255

    if (num_gps_locked == num_mboards and num_mboards > 1) {
      //Check to see if all USRP times are aligned
      //First, wait for PPS.
      uhd::time_spec_t time_last_pps = s->usrp->get_time_last_pps();

      while (time_last_pps == s->usrp->get_time_last_pps()) {
        boost::this_thread::sleep(boost::posix_time::milliseconds(1));
      }

      //Sleep a little to make sure all devices have seen a PPS edge
      boost::this_thread::sleep(boost::posix_time::milliseconds(200));
      //Compare times across all mboards
      bool all_matched = true;
      uhd::time_spec_t mboard0_time = s->usrp->get_time_last_pps(0);

      for (size_t mboard = 1; mboard < num_mboards; mboard++) {
        uhd::time_spec_t mboard_time = s->usrp->get_time_last_pps(mboard);

        if (mboard_time != mboard0_time) {
          all_matched = false;
          std::cerr << (boost::format("ERROR: Times are not aligned: USRP 0=%0.9f, USRP %d=%0.9f")
                        % mboard0_time.get_real_secs()
                        % mboard
                        % mboard_time.get_real_secs()) << std::endl;
        }
      }

      if (all_matched) {
        std::cout << "SUCCESS: USRP times aligned" << std::endl << std::endl;
      } else {
        std::cout << "ERROR: USRP times are not aligned" << std::endl << std::endl;
      }
Florian Kaltenberger's avatar
Florian Kaltenberger committed
256
    }
257 258 259 260 261 262 263 264 265
  } catch (std::exception &e) {
    std::cout << boost::format("\nError: %s") % e.what();
    std::cout << boost::format("This could mean that you have not installed the GPSDO correctly.\n\n");
    std::cout << boost::format("Visit one of these pages if the problem persists:\n");
    std::cout << boost::format(" * N2X0/E1X0: http://files.ettus.com/manual/page_gpsdo.html");
    std::cout << boost::format(" * X3X0: http://files.ettus.com/manual/page_gpsdo_x3x0.html\n\n");
    std::cout << boost::format(" * E3X0: http://files.ettus.com/manual/page_usrp_e3x0.html#e3x0_hw_gps\n\n");
    exit(EXIT_FAILURE);
  }
Raymond Knopp's avatar
 
Raymond Knopp committed
266

267
  return EXIT_SUCCESS;
Florian Kaltenberger's avatar
Florian Kaltenberger committed
268
}
Raymond Knopp's avatar
 
Raymond Knopp committed
269

270 271 272
/*! \brief Called to start the USRP transceiver. Return 0 if OK, < 0 if error
    @param device pointer to the device structure specific to the RF hardware target
*/
laurent's avatar
laurent committed
273
static int trx_usrp_start(openair0_device *device) {
274
  usrp_state_t *s = (usrp_state_t *)device->priv;
275

276 277
  // setup GPIO for TDD, GPIO(4) = ATR_RX
  //set data direction register (DDR) to output
278
  s->usrp->set_gpio_attr("FP0", "DDR", 0xfff, 0xfff);
279
  //set lower 7 bits to be controlled automatically by ATR (the rest 5 bits are controlled manually)
280
  s->usrp->set_gpio_attr("FP0", "CTRL", 0x7f,0xfff);
281
  //set pins 4 (RX_TX_Switch) and 6 (Shutdown PA) to 1 when the radio is only receiving (ATR_RX)
282
  s->usrp->set_gpio_attr("FP0", "ATR_RX", (1<<4)|(1<<6), 0x7f);
283 284 285
  // set pin 5 (Shutdown LNA) to 1 when the radio is transmitting and receiveing (ATR_XX)
  // (we use full duplex here, because our RX is on all the time - this might need to change later)
  s->usrp->set_gpio_attr("FP0", "ATR_XX", (1<<5), 0x7f);
286
  // set the output pins to 1
287 288
  s->usrp->set_gpio_attr("FP0", "OUT", 7<<7, 0xf80);

289 290 291 292 293 294 295 296 297 298 299 300
  s->wait_for_first_pps = 1;
  s->rx_count = 0;
  s->tx_count = 0;
  //s->first_tx = 1;
  //s->first_rx = 1;
  s->rx_timestamp = 0;

  s->usrp->set_time_next_pps(uhd::time_spec_t(0.0));
  // wait for the pps to change
  uhd::time_spec_t time_last_pps = s->usrp->get_time_last_pps();
  while (time_last_pps == s->usrp->get_time_last_pps()) {
    boost::this_thread::sleep(boost::posix_time::milliseconds(1));
301 302
  }

303
  uhd::stream_cmd_t cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
304
  cmd.time_spec = uhd::time_spec_t(1.0);
305 306
  cmd.stream_now = false; // start at constant delay
  s->rx_stream->issue_stream_cmd(cmd);
307

308
  return 0;
Raymond Knopp's avatar
 
Raymond Knopp committed
309
}
laurent's avatar
laurent committed
310
/*! \brief Terminate operation of the USRP transceiver -- free all associated resources
311 312
 * \param device the hardware to use
 */
laurent's avatar
laurent committed
313
static void trx_usrp_end(openair0_device *device) {
314 315
  if (device == NULL)
    return;
316

317
  usrp_state_t *s = (usrp_state_t *)device->priv;
318

319 320
  if (s == NULL)
    return;
321
  iqrecorder_end(device);
322 323


Raymond Knopp's avatar
 
Raymond Knopp committed
324
}
325

326 327
/*! \brief Called to send samples to the USRP RF target
      @param device pointer to the device structure specific to the RF hardware target
328
      @param timestamp The timestamp at which the first sample MUST be sent
329 330
      @param buff Buffer which holds the samples
      @param nsamps number of samples to be sent
331
      @param antenna_id index of the antenna if the device has multiple antennas
332
      @param flags flags must be set to TRUE if timestamp parameter needs to be applied
laurent's avatar
laurent committed
333
*/
334 335 336 337 338 339
static int trx_usrp_write(openair0_device *device,
			  openair0_timestamp timestamp,
			  void **buff,
			  int nsamps,
			  int cc,
			  int flags) {
340
  int ret=0;
341 342
  usrp_state_t *s = (usrp_state_t *)device->priv;
  int nsamps2;  // aligned to upper 32 or 16 byte boundary
343

344 345
  int flags_lsb = flags&0xff;
  int flags_msb = (flags>>8)&0xff;
346

WANG Tsu-Han's avatar
WANG Tsu-Han committed
347 348 349
  int end;
  openair0_thread_t *write_thread = &device->write_thread;
  openair0_write_package_t *write_package = write_thread->write_package;
350

WANG Tsu-Han's avatar
WANG Tsu-Han committed
351
  AssertFatal( MAX_WRITE_THREAD_BUFFER_SIZE >= cc,"Do not support more than %d cc number\n", MAX_WRITE_THREAD_BUFFER_SIZE);
laurent's avatar
laurent committed
352

Raymond Knopp's avatar
Raymond Knopp committed
353
    boolean_t first_packet_state=false,last_packet_state=false;
354

355
    if (flags_lsb == 2) { // start of burst
356 357 358
      //      s->tx_md.start_of_burst = true;
      //      s->tx_md.end_of_burst = false;
      first_packet_state = true;
359
      last_packet_state  = false;
360
    } else if (flags_lsb == 3) { // end of burst
361 362 363
      //s->tx_md.start_of_burst = false;
      //s->tx_md.end_of_burst = true;
      first_packet_state = false;
364
      last_packet_state  = true;
365 366 367
    } else if (flags_lsb == 4) { // start and end
    //  s->tx_md.start_of_burst = true;
    //  s->tx_md.end_of_burst = true;
368
      first_packet_state = true;
369
      last_packet_state  = true;
370 371 372
    } else if (flags_lsb==1) { // middle of burst
    //  s->tx_md.start_of_burst = false;
    //  s->tx_md.end_of_burst = false;
373
      first_packet_state = false;
374
      last_packet_state  = false;
375 376 377 378 379 380 381
    }
    else if (flags_lsb==10) { // fail safe mode
     // s->tx_md.has_time_spec = false;
     // s->tx_md.start_of_burst = false;
     // s->tx_md.end_of_burst = true;
     first_packet_state = false;
     last_packet_state  = true;
382
    }
383

384
  if(usrp_tx_thread == 0){
385
#if defined(__x86_64) || defined(__i386__)
386 387
  #ifdef __AVX2__
      nsamps2 = (nsamps+7)>>3;
388
      __m256i buff_tx[cc<2?2:cc][nsamps2];
389
  #else
390
    nsamps2 = (nsamps+3)>>2;
391
    __m128i buff_tx[cc<2?2:cc][nsamps2];
392
  #endif
393
#elif defined(__arm__)
394
    nsamps2 = (nsamps+3)>>2;
395
    int16x8_t buff_tx[cc<2?2:cc][nsamps2];
396
#else
397
#error Unsupported CPU architecture, USRP device cannot be built
398
#endif
399 400 401 402

    // bring RX data into 12 LSBs for softmodem RX
    for (int i=0; i<cc; i++) {
      for (int j=0; j<nsamps2; j++) {
403 404
#if defined(__x86_64__) || defined(__i386__)
#ifdef __AVX2__
405
        buff_tx[i][j] = _mm256_slli_epi16(((__m256i *)buff[i])[j],4);
406
#else
407
        buff_tx[i][j] = _mm_slli_epi16(((__m128i *)buff[i])[j],4);
408 409
#endif
#elif defined(__arm__)
410
        buff_tx[i][j] = vshlq_n_s16(((int16x8_t *)buff[i])[j],4);
411
#endif
412
      }
laurent's avatar
laurent committed
413 414
    }

Raymond Knopp's avatar
Raymond Knopp committed
415
    s->tx_md.has_time_spec  = true;
416
    s->tx_md.start_of_burst = (s->tx_count==0) ? true : first_packet_state;
417
    s->tx_md.end_of_burst   = last_packet_state;
418
    s->tx_md.time_spec      = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate);
419
    s->tx_count++;
420

Rakesh's avatar
Rakesh committed
421
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_BEAM_SWITCHING_GPIO,1);
422 423 424 425 426 427 428
    // bit 3 enables gpio (for backward compatibility)
    if (flags_msb&8) {
      // push GPIO bits 7-9 from flags_msb
      int gpio789=(flags_msb&7)<<7;
      s->usrp->set_command_time(s->tx_md.time_spec);
      s->usrp->set_gpio_attr("FP0", "OUT", gpio789, 0x380);
      s->usrp->clear_command_time();
429
    }
Rakesh's avatar
Rakesh committed
430
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_BEAM_SWITCHING_GPIO,0);
431

432
    if (cc>1) {
433
      std::vector<void *> buff_ptrs;
434

435 436
      for (int i=0; i<cc; i++)
        buff_ptrs.push_back(&(((int16_t *)buff_tx[i])[0]));
437

438
      ret = (int)s->tx_stream->send(buff_ptrs, nsamps, s->tx_md);
439
    }
440 441 442 443
    else {
      ret = (int)s->tx_stream->send(&(((int16_t *)buff_tx[0])[0]), nsamps, s->tx_md);
    }

444
    if (ret != nsamps) LOG_E(HW,"[xmit] tx samples %d != %d\n",ret,nsamps);
445
    return ret;
446
  }
447 448
  else{
    pthread_mutex_lock(&write_thread->mutex_write);
449

450 451 452 453
    if(write_thread->count_write >= MAX_WRITE_THREAD_PACKAGE){
      LOG_W(HW,"Buffer overflow, count_write = %d, start = %d end = %d, resetting write package\n", write_thread->count_write, write_thread->start, write_thread->end);
      write_thread->end = write_thread->start;
      write_thread->count_write = 0;
454
    }
WANG Tsu-Han's avatar
WANG Tsu-Han committed
455

456 457 458 459 460 461 462 463 464 465 466
    end = write_thread->end;
    write_package[end].timestamp    = timestamp;
    write_package[end].nsamps       = nsamps;
    write_package[end].cc           = cc;
    write_package[end].first_packet = first_packet_state;
    write_package[end].last_packet  = last_packet_state;
    write_package[end].flags_msb    = flags_msb;
    for (int i = 0; i < cc; i++)
      write_package[end].buff[i]    = buff[i];
    write_thread->count_write++;
    write_thread->end = (write_thread->end + 1)% MAX_WRITE_THREAD_PACKAGE;
467
    LOG_D(HW,"Signaling TX TS %llu\n",(unsigned long long)timestamp);
468 469
    pthread_cond_signal(&write_thread->cond_write);
    pthread_mutex_unlock(&write_thread->mutex_write);
470
    return 0;
471
  }
WANG Tsu-Han's avatar
WANG Tsu-Han committed
472 473 474 475 476 477 478 479 480 481 482 483

}

//-----------------------start--------------------------
/*! \brief Called to send samples to the USRP RF target
      @param device pointer to the device structure specific to the RF hardware target
      @param timestamp The timestamp at which the first sample MUST be sent
      @param buff Buffer which holds the samples
      @param nsamps number of samples to be sent
      @param antenna_id index of the antenna if the device has multiple antennas
      @param flags flags must be set to TRUE if timestamp parameter needs to be applied
*/
484
void *trx_usrp_write_thread(void * arg){
WANG Tsu-Han's avatar
WANG Tsu-Han committed
485 486 487 488 489
  int ret=0;
  openair0_device *device=(openair0_device *)arg;
  openair0_thread_t *write_thread = &device->write_thread;
  openair0_write_package_t *write_package = write_thread->write_package;

WANG Tsu-Han's avatar
WANG Tsu-Han committed
490 491 492 493 494 495 496 497 498 499
  usrp_state_t *s;
  int nsamps2;  // aligned to upper 32 or 16 byte boundary
  int start;
  openair0_timestamp timestamp;
  void               **buff;
  int                nsamps;
  int                cc;
  signed char        first_packet;
  signed char        last_packet;
  int                flags_msb;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
500 501 502

  while(1){
    pthread_mutex_lock(&write_thread->mutex_write);
WANG Tsu-Han's avatar
WANG Tsu-Han committed
503
    while (write_thread->count_write == 0) {
WANG Tsu-Han's avatar
WANG Tsu-Han committed
504 505
      pthread_cond_wait(&write_thread->cond_write,&write_thread->mutex_write); // this unlocks mutex_rxtx while waiting and then locks it again
    }
WANG Tsu-Han's avatar
WANG Tsu-Han committed
506
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_THREAD, 1 );
507 508 509 510 511 512 513 514
    s = (usrp_state_t *)device->priv;
    start = write_thread->start;
    timestamp    = write_package[start].timestamp;
    buff         = write_package[start].buff;
    nsamps       = write_package[start].nsamps;
    cc           = write_package[start].cc;
    first_packet = write_package[start].first_packet;
    last_packet  = write_package[start].last_packet;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
515
    flags_msb    = write_package[start].flags_msb;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
516 517
    write_thread->start = (write_thread->start + 1)% MAX_WRITE_THREAD_PACKAGE;
    write_thread->count_write--;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
518
    pthread_mutex_unlock(&write_thread->mutex_write);
519
    /*if(write_thread->count_write != 0){
WANG Tsu-Han's avatar
WANG Tsu-Han committed
520
      LOG_W(HW,"count write = %d, start = %d, end = %d\n", write_thread->count_write, write_thread->start, write_thread->end);
521
    }*/
WANG Tsu-Han's avatar
WANG Tsu-Han committed
522 523 524 525

    #if defined(__x86_64) || defined(__i386__)
      #ifdef __AVX2__
        nsamps2 = (nsamps+7)>>3;
526
        __m256i buff_tx[cc<2?2:cc][nsamps2];
WANG Tsu-Han's avatar
WANG Tsu-Han committed
527 528
      #else
        nsamps2 = (nsamps+3)>>2;
529
        __m128i buff_tx[cc<2?2:cc][nsamps2];
WANG Tsu-Han's avatar
WANG Tsu-Han committed
530 531 532
      #endif
    #elif defined(__arm__)
      nsamps2 = (nsamps+3)>>2;
533
      int16x8_t buff_tx[cc<2?2:cc][nsamps2];
WANG Tsu-Han's avatar
WANG Tsu-Han committed
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
    #else
    #error Unsupported CPU architecture, USRP device cannot be built
    #endif

    // bring RX data into 12 LSBs for softmodem RX
    for (int i=0; i<cc; i++) {
      for (int j=0; j<nsamps2; j++) {
        #if defined(__x86_64__) || defined(__i386__)
          #ifdef __AVX2__
            buff_tx[i][j] = _mm256_slli_epi16(((__m256i *)buff[i])[j],4);
          #else
            buff_tx[i][j] = _mm_slli_epi16(((__m128i *)buff[i])[j],4);
          #endif
        #elif defined(__arm__)
          buff_tx[i][j] = vshlq_n_s16(((int16x8_t *)buff[i])[j],4);
        #endif
      }
    }
552

553

Raymond Knopp's avatar
Raymond Knopp committed
554
    s->tx_md.has_time_spec  = true;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
555 556
    s->tx_md.start_of_burst = (s->tx_count==0) ? true : first_packet;
    s->tx_md.end_of_burst   = last_packet;
557
    s->tx_md.time_spec      = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate);
Raymond Knopp's avatar
Raymond Knopp committed
558
    LOG_D(PHY,"usrp_tx_write: tx_count %llu SoB %d, EoB %d, TS %llu\n",(unsigned long long)s->tx_count,s->tx_md.start_of_burst,s->tx_md.end_of_burst,(unsigned long long)timestamp); 
559
    s->tx_count++;
560

561 562 563 564 565 566 567 568 569
    // bit 3 enables gpio (for backward compatibility)
    if (flags_msb&8) {
      // push GPIO bits 7-9 from flags_msb
      int gpio789=(flags_msb&7)<<7;
      s->usrp->set_command_time(s->tx_md.time_spec);
      s->usrp->set_gpio_attr("FP0", "OUT", gpio789, 0x380);
      s->usrp->clear_command_time();
    }

570
    if (cc>1) {
571
      std::vector<void *> buff_ptrs;
572

573 574
      for (int i=0; i<cc; i++)
        buff_ptrs.push_back(&(((int16_t *)buff_tx[i])[0]));
575

576
      ret = (int)s->tx_stream->send(buff_ptrs, nsamps, s->tx_md);
577
    }
578 579 580
    else {
      ret = (int)s->tx_stream->send(&(((int16_t *)buff_tx[0])[0]), nsamps, s->tx_md);
    }
581

WANG Tsu-Han's avatar
WANG Tsu-Han committed
582
    if (ret != nsamps) LOG_E(HW,"[xmit] tx samples %d != %d\n",ret,nsamps);
WANG Tsu-Han's avatar
WANG Tsu-Han committed
583 584
    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_USRP_SEND_RETURN, ret );
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_THREAD, 0 );
585

586
  }
587

WANG Tsu-Han's avatar
WANG Tsu-Han committed
588
  return NULL;
Raymond Knopp's avatar
 
Raymond Knopp committed
589 590
}

591
int trx_usrp_write_init(openair0_device *device){
WANG Tsu-Han's avatar
WANG Tsu-Han committed
592

Laurent OpenCells's avatar
Laurent OpenCells committed
593
  //uhd::set_thread_priority_safe(1.0);
WANG Tsu-Han's avatar
WANG Tsu-Han committed
594 595 596 597 598
  openair0_thread_t *write_thread = &device->write_thread;
  printf("initializing tx write thread\n");

  write_thread->start              = 0;
  write_thread->end                = 0;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
599
  write_thread->count_write        = 0;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
600
  printf("end of tx write thread\n");
601 602
  pthread_mutex_init(&write_thread->mutex_write, NULL);
  pthread_cond_init(&write_thread->cond_write, NULL);
WANG Tsu-Han's avatar
WANG Tsu-Han committed
603 604 605 606 607 608 609
  pthread_create(&write_thread->pthread_write,NULL,trx_usrp_write_thread,(void *)device);

  return(0);
}

//---------------------end-------------------------

610 611 612 613 614 615 616 617 618 619 620
/*! \brief Receive samples from hardware.
 * Read \ref nsamps samples from each channel to buffers. buff[0] is the array for
 * the first channel. *ptimestamp is the time at which the first sample
 * was received.
 * \param device the hardware to use
 * \param[out] ptimestamp the time at which the first sample was received.
 * \param[out] buff An array of pointers to buffers for received samples. The buffers must be large enough to hold the number of samples \ref nsamps.
 * \param nsamps Number of samples. One sample is 2 byte I + 2 byte Q => 4 byte.
 * \param antenna_id Index of antenna for which to receive samples
 * \returns the number of sample read
*/
laurent's avatar
laurent committed
621
static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
622
  usrp_state_t *s = (usrp_state_t *)device->priv;
623
  int samples_received=0;
624
  int nsamps2;  // aligned to upper 32 or 16 byte boundary
625 626
#if defined(__x86_64) || defined(__i386__)
#ifdef __AVX2__
627
  nsamps2 = (nsamps+7)>>3;
628
  __m256i buff_tmp[cc<2 ? 2 : cc][nsamps2];
629
#else
630
  nsamps2 = (nsamps+3)>>2;
631
  __m128i buff_tmp[cc<2 ? 2 : cc][nsamps2];
632 633
#endif
#elif defined(__arm__)
634
  nsamps2 = (nsamps+3)>>2;
635
  int16x8_t buff_tmp[cc<2 ? 2 : cc][nsamps2];
636 637
#endif

638 639 640 641 642 643 644
  int rxshift;
  switch (device->type) {
     case USRP_B200_DEV:
        rxshift=4;
        break;
     case USRP_X300_DEV:
     case USRP_N300_DEV:
Eurecom's avatar
Eurecom committed
645
        rxshift=2;
646 647
        break;
     default:
648 649
       AssertFatal(1==0,"Shouldn't be here\n");
  }
650

651 652
    samples_received=0;
    while (samples_received != nsamps) {
653

654
      if (cc>1) {
655
      // receive multiple channels (e.g. RF A and RF B)
656
        std::vector<void *> buff_ptrs;
657

658
        for (int i=0; i<cc; i++) buff_ptrs.push_back(buff_tmp[i]+samples_received);
659

660 661
        samples_received += s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md);
      } else {
662
      // receive a single channel (e.g. from connector RF A)
663

664
        samples_received += s->rx_stream->recv((void*)((int32_t*)buff_tmp[0]+samples_received),
665
                                               nsamps-samples_received, s->rx_md);
666 667 668
      }
      if  ((s->wait_for_first_pps == 0) && (s->rx_md.error_code!=uhd::rx_metadata_t::ERROR_CODE_NONE))
        break;
669

670 671
      if ((s->wait_for_first_pps == 1) && (samples_received != nsamps)) {
        printf("sleep...\n"); //usleep(100);
672
      }
673
    }
674
    if (samples_received == nsamps) s->wait_for_first_pps=0;
675 676 677 678

    // bring RX data into 12 LSBs for softmodem RX
    for (int i=0; i<cc; i++) {
      for (int j=0; j<nsamps2; j++) {
679 680
#if defined(__x86_64__) || defined(__i386__)
#ifdef __AVX2__
681
        // FK: in some cases the buffer might not be 32 byte aligned, so we cannot use avx2
682

683
        if ((((uintptr_t) buff[i])&0x1F)==0) {
684
          ((__m256i *)buff[i])[j] = _mm256_srai_epi16(buff_tmp[i][j],rxshift);
685
        } else {
686 687
          ((__m128i *)buff[i])[2*j] = _mm_srai_epi16(((__m128i *)buff_tmp[i])[2*j],rxshift);
          ((__m128i *)buff[i])[2*j+1] = _mm_srai_epi16(((__m128i *)buff_tmp[i])[2*j+1],rxshift);
688 689
        }

690
#else
691
        ((__m128i *)buff[i])[j] = _mm_srai_epi16(buff_tmp[i][j],rxshift);
692 693
#endif
#elif defined(__arm__)
694
        ((int16x8_t *)buff[i])[j] = vshrq_n_s16(buff_tmp[i][j],rxshift);
695
#endif
bruno mongazon-cazavet's avatar
bruno mongazon-cazavet committed
696
      }
697
    }
698

699 700
    if (samples_received < nsamps) {
      LOG_E(HW,"[recv] received %d samples out of %d\n",samples_received,nsamps);
701
    }
702

703 704
  if ( s->rx_md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE)
    LOG_E(HW, "%s\n", s->rx_md.to_pp_string(true).c_str());
705

706 707 708
  s->rx_count += nsamps;
  s->rx_timestamp = s->rx_md.time_spec.to_ticks(s->sample_rate);
  *ptimestamp = s->rx_timestamp;
709

Rakesh's avatar
Rakesh committed
710
  // push GPIO bits 7-9 from flags_msb
Rakesh's avatar
Rakesh committed
711
   /*s->usrp->set_command_time(uhd::time_spec_t::from_ticks((s->rx_timestamp+(2*nsamps)),s->sample_rate));
Rakesh's avatar
Rakesh committed
712 713
   s->usrp->set_gpio_attr("FP0", "OUT", gpio789<<7, 0x380);
   s->usrp->clear_command_time();
Rakesh's avatar
Rakesh committed
714
   gpio789 = (gpio789+1)&7;*/
715
  recplay_state_t *recPlay=device->recplay_state;
Rakesh's avatar
Rakesh committed
716

717
  if ( recPlay != NULL) { // record mode
718
    // Copy subframes to memory (later dump on a file)
719 720 721 722 723 724 725 726 727 728 729 730 731
    if (recPlay->nbSamplesBlocks < device->openair0_cfg->recplay_conf->u_sf_max &&
        recPlay->maxSizeBytes > (recPlay->currentPtr-(uint8_t *)recPlay->ms_sample) +
        sizeof(iqrec_t) + nsamps*4 ) {
      iqrec_t *hdr=(iqrec_t *)recPlay->currentPtr;
      hdr->header = BELL_LABS_IQ_HEADER;
      hdr->ts = *ptimestamp;
      hdr->nbBytes=nsamps*4;
      memcpy(hdr+1, buff[0], nsamps*4);
      recPlay->currentPtr+=sizeof(iqrec_t)+nsamps*4;
      recPlay->nbSamplesBlocks++;
      LOG_D(HW,"recorded %d samples, for TS %lu, shift in buffer %ld\n", nsamps, hdr->ts, recPlay->currentPtr-(uint8_t *)recPlay->ms_sample);
    } else
      exit_function(__FILE__, __FUNCTION__, __LINE__,"Recording reaches max iq limit\n");
732
  }
733

734
  return samples_received;
Raymond Knopp's avatar
 
Raymond Knopp committed
735 736
}

737 738 739 740
/*! \brief Compares two variables within precision
 * \param a first variable
 * \param b second variable
*/
laurent's avatar
laurent committed
741
static bool is_equal(double a, double b) {
742
  return std::fabs(a-b) < std::numeric_limits<double>::epsilon();
Raymond Knopp's avatar
 
Raymond Knopp committed
743
}
Raymond Knopp's avatar
 
Raymond Knopp committed
744

745
void *freq_thread(void *arg) {
746 747 748 749
  openair0_device *device=(openair0_device *)arg;
  usrp_state_t *s = (usrp_state_t *)device->priv;
  s->usrp->set_tx_freq(device->openair0_cfg[0].tx_freq[0]);
  s->usrp->set_rx_freq(device->openair0_cfg[0].rx_freq[0]);
750
  return NULL;
751 752
}
/*! \brief Set frequencies (TX/RX). Spawns a thread to handle the frequency change to not block the calling thread
753 754 755
 * \param device the hardware to use
 * \param openair0_cfg RF frontend parameters set by application
 * \param dummy dummy variable not used
laurent's avatar
laurent committed
756
 * \returns 0 in success
757
 */
758 759 760 761 762 763 764 765 766 767 768 769
int trx_usrp_set_freq(openair0_device *device, openair0_config_t *openair0_cfg, int dont_block) {
  usrp_state_t *s = (usrp_state_t *)device->priv;
  pthread_t f_thread;
  printf("Setting USRP TX Freq %f, RX Freq %f\n",openair0_cfg[0].tx_freq[0],openair0_cfg[0].rx_freq[0]);

  // spawn a thread to handle the frequency change to not block the calling thread
  if (dont_block == 1)
    pthread_create(&f_thread,NULL,freq_thread,(void *)device);
  else {
    s->usrp->set_tx_freq(device->openair0_cfg[0].tx_freq[0]);
    s->usrp->set_rx_freq(device->openair0_cfg[0].rx_freq[0]);
  }
Raymond Knopp's avatar
 
Raymond Knopp committed
770

771
  return(0);
Raymond Knopp's avatar
 
Raymond Knopp committed
772 773
}

laurent's avatar
laurent committed
774
/*! \brief Set RX frequencies
775 776
 * \param device the hardware to use
 * \param openair0_cfg RF frontend parameters set by application
laurent's avatar
laurent committed
777
 * \returns 0 in success
778
 */
779 780 781 782 783 784 785
int openair0_set_rx_frequencies(openair0_device *device, openair0_config_t *openair0_cfg) {
  usrp_state_t *s = (usrp_state_t *)device->priv;
  uhd::tune_request_t rx_tune_req(openair0_cfg[0].rx_freq[0]);
  rx_tune_req.rf_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
  rx_tune_req.rf_freq = openair0_cfg[0].rx_freq[0];
  s->usrp->set_rx_freq(rx_tune_req);
  return(0);
Raymond Knopp's avatar
 
Raymond Knopp committed
786 787
}

788 789 790
/*! \brief Set Gains (TX/RX)
 * \param device the hardware to use
 * \param openair0_cfg RF frontend parameters set by application
laurent's avatar
laurent committed
791
 * \returns 0 in success
792
 */
793
int trx_usrp_set_gains(openair0_device *device,
laurent's avatar
laurent committed
794
                       openair0_config_t *openair0_cfg) {
795 796 797 798 799 800 801
  usrp_state_t *s = (usrp_state_t *)device->priv;
  ::uhd::gain_range_t gain_range_tx = s->usrp->get_tx_gain_range(0);
  s->usrp->set_tx_gain(gain_range_tx.stop()-openair0_cfg[0].tx_gain[0]);
  ::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(0);

  // limit to maximum gain
  if (openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0] > gain_range.stop()) {
802
    LOG_E(HW,"RX Gain 0 too high, reduce by %f dB\n",
803 804 805
          openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0] - gain_range.stop());
    exit(-1);
  }
laurent's avatar
laurent committed
806

807
  s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0]);
808
  LOG_I(HW,"Setting USRP RX gain to %f (rx_gain %f,gain_range.stop() %f)\n",
809 810 811
        openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0],
        openair0_cfg[0].rx_gain[0],gain_range.stop());
  return(0);
Raymond Knopp's avatar
 
Raymond Knopp committed
812
}
813

814 815 816
/*! \brief Stop USRP
 * \param card refers to the hardware index to use
 */
817 818
int trx_usrp_stop(openair0_device *device) {
  return(0);
819
}
820

821
/*! \brief USRPB210 RX calibration table */
822
rx_gain_calib_table_t calib_table_b210[] = {
823 824 825 826 827 828
  {3500000000.0,44.0},
  {2660000000.0,49.0},
  {2300000000.0,50.0},
  {1880000000.0,53.0},
  {816000000.0,58.0},
  {-1,0}
laurent's avatar
laurent committed
829
};
830

831
/*! \brief USRPB210 RX calibration table */
832
rx_gain_calib_table_t calib_table_b210_38[] = {
833 834 835 836 837 838
  {3500000000.0,44.0},
  {2660000000.0,49.8},
  {2300000000.0,51.0},
  {1880000000.0,53.0},
  {816000000.0,57.0},
  {-1,0}
laurent's avatar
laurent committed
839
};
840

841
/*! \brief USRPx310 RX calibration table */
842
rx_gain_calib_table_t calib_table_x310[] = {
843 844 845 846 847 848
  {3500000000.0,77.0},
  {2660000000.0,81.0},
  {2300000000.0,81.0},
  {1880000000.0,82.0},
  {816000000.0,85.0},
  {-1,0}
laurent's avatar
laurent committed
849 850
};

851 852 853 854 855 856 857 858 859 860 861
/*! \brief USRPB210 RX calibration table */
rx_gain_calib_table_t calib_table_n310[] = {
  {3500000000.0,0.0},
  {2660000000.0,0.0},
  {2300000000.0,0.0},
  {1880000000.0,0.0},
  {816000000.0, 0.0},
  {-1,0}
};


laurent's avatar
laurent committed
862
/*! \brief Set RX gain offset
863 864
 * \param openair0_cfg RF frontend parameters set by application
 * \param chain_index RF chain to apply settings to
laurent's avatar
laurent committed
865
 * \returns 0 in success
866
 */
867
void set_rx_gain_offset(openair0_config_t *openair0_cfg, int chain_index,int bw_gain_adjust) {
868 869 870
  int i=0;
  // loop through calibration table to find best adjustment factor for RX frequency
  double min_diff = 6e9,diff,gain_adj=0.0;
871

872 873
  if (bw_gain_adjust==1) {
    switch ((int)openair0_cfg[0].sample_rate) {
874 875 876
      case 46080000:
        break;

877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
      case 30720000:
        break;

      case 23040000:
        gain_adj=1.25;
        break;

      case 15360000:
        gain_adj=3.0;
        break;

      case 7680000:
        gain_adj=6.0;
        break;

      case 3840000:
        gain_adj=9.0;
        break;

      case 1920000:
        gain_adj=12.0;
        break;

      default:
901
        LOG_E(HW,"unknown sampling rate %d\n",(int)openair0_cfg[0].sample_rate);
902
        //exit(-1);
903
        break;
904
    }
905 906 907 908
  }

  while (openair0_cfg->rx_gain_calib_table[i].freq>0) {
    diff = fabs(openair0_cfg->rx_freq[chain_index] - openair0_cfg->rx_gain_calib_table[i].freq);
909
    LOG_I(HW,"cal %d: freq %f, offset %f, diff %f\n",
910 911 912 913 914 915 916
          i,
          openair0_cfg->rx_gain_calib_table[i].freq,
          openair0_cfg->rx_gain_calib_table[i].offset,diff);

    if (min_diff > diff) {
      min_diff = diff;
      openair0_cfg->rx_gain_offset[chain_index] = openair0_cfg->rx_gain_calib_table[i].offset+gain_adj;
laurent's avatar
laurent committed
917
    }
918 919 920

    i++;
  }
921 922
}

laurent's avatar
laurent committed
923
/*! \brief print the USRP statistics
924 925 926
* \param device the hardware to use
* \returns  0 on success
*/
927 928
int trx_usrp_get_stats(openair0_device *device) {
  return(0);
929
}
930

laurent's avatar
laurent committed
931 932 933 934
/*! \brief Reset the USRP statistics
 * \param device the hardware to use
 * \returns  0 on success
 */
935 936
int trx_usrp_reset_stats(openair0_device *device) {
  return(0);
937
}
938

939
extern "C" {
940
  int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
941 942
    LOG_I(HW, "openair0_cfg[0].sdr_addrs == '%s'\n", openair0_cfg[0].sdr_addrs);
    LOG_I(HW, "openair0_cfg[0].clock_source == '%d' (internal = %d, external = %d)\n", openair0_cfg[0].clock_source,internal,external);
943
    usrp_state_t *s ;
rmagueta's avatar
rmagueta committed
944
    int choffset = 0;
945

946
    if ( device->priv == NULL) {
947 948 949
      s=(usrp_state_t *)calloc(sizeof(usrp_state_t),1);
      device->priv=s;
      AssertFatal( s!=NULL,"USRP device: memory allocation failure\n");
950 951 952 953
    } else {
      LOG_E(HW, "multiple device init detected\n");
      return 0;
    }
954

955 956 957 958 959 960 961 962
    device->openair0_cfg = openair0_cfg;
    device->trx_start_func = trx_usrp_start;
    device->trx_get_stats_func = trx_usrp_get_stats;
    device->trx_reset_stats_func = trx_usrp_reset_stats;
    device->trx_end_func   = trx_usrp_end;
    device->trx_stop_func  = trx_usrp_stop;
    device->trx_set_freq_func = trx_usrp_set_freq;
    device->trx_set_gains_func   = trx_usrp_set_gains;
963
    device->trx_write_init = trx_usrp_write_init;
964 965


966
    // hotfix! to be checked later
Laurent OpenCells's avatar
Laurent OpenCells committed
967
    //uhd::set_thread_priority_safe(1.0);
968 969 970
    // Initialize USRP device
    int vers=0,subvers=0,subsubvers=0;
    int bw_gain_adjust=0;
971

972 973
    if (device->openair0_cfg->recplay_mode == RECPLAY_RECORDMODE) {
      std::cerr << "USRP device initialized in subframes record mode" << std::endl;
974
    }
975

976 977 978 979
    sscanf(uhd::get_version_string().c_str(),"%d.%d.%d",&vers,&subvers,&subsubvers);
    LOG_I(HW,"UHD version %s (%d.%d.%d)\n",
          uhd::get_version_string().c_str(),vers,subvers,subsubvers);
    std::string args;
980

981 982
    if (openair0_cfg[0].sdr_addrs == NULL) {
      args = "type=b200";
983
    } else {
984 985 986
      args = openair0_cfg[0].sdr_addrs;
      LOG_I(HW,"Checking for USRP with args %s\n",openair0_cfg[0].sdr_addrs);
    }
987

988
    uhd::device_addrs_t device_adds = uhd::device::find(args);
989

990 991 992 993 994 995 996 997 998
    if (device_adds.size() == 0) {
      LOG_E(HW,"No USRP Device Found.\n ");
      free(s);
      return -1;
    } else if (device_adds.size() > 1) {
      LOG_E(HW,"More than one USRP Device Found. Please specify device more precisely in config file.\n");
      free(s);
      return -1;
    }
999

1000 1001
    LOG_I(HW,"Found USRP %s\n", device_adds[0].get("type").c_str());
    double usrp_master_clock;
1002

1003 1004 1005 1006 1007 1008
    if (device_adds[0].get("type") == "b200") {
      device->type = USRP_B200_DEV;
      usrp_master_clock = 30.72e6;
      args += boost::str(boost::format(",master_clock_rate=%f") % usrp_master_clock);
      args += ",num_send_frames=256,num_recv_frames=256, send_frame_size=7680, recv_frame_size=7680" ;
    }
1009

1010 1011
    if (device_adds[0].get("type") == "n3xx") {
      printf("Found USRP n300\n");
1012
      device->type=USRP_N300_DEV;
1013 1014 1015 1016
      usrp_master_clock = 122.88e6;
      args += boost::str(boost::format(",master_clock_rate=%f") % usrp_master_clock);
      //args += ", send_buff_size=33554432";
    }
1017

1018 1019 1020 1021 1022
    if (device_adds[0].get("type") == "x300") {
      printf("Found USRP x300\n");
      device->type=USRP_X300_DEV;
      usrp_master_clock = 184.32e6;
      args += boost::str(boost::format(",master_clock_rate=%f") % usrp_master_clock);
1023

1024 1025 1026 1027
      // USRP recommended: https://files.ettus.com/manual/page_usrp_x3x0_config.html
      if ( 0 != system("sysctl -w net.core.rmem_max=33554432 net.core.wmem_max=33554432") )
        LOG_W(HW,"Can't set kernel parameters for X3xx\n");
    }
1028

1029
    s->usrp = uhd::usrp::multi_usrp::make(args);
1030

1031
    if (args.find("clock_source")==std::string::npos) {
1032 1033
	if (openair0_cfg[0].clock_source == internal) {
	  s->usrp->set_clock_source("internal");
1034
	  LOG_I(HW,"Setting clock source to internal\n");
1035 1036 1037
	}
	else if (openair0_cfg[0].clock_source == external ) {
	  s->usrp->set_clock_source("external");
1038
	  LOG_I(HW,"Setting clock source to external\n");
1039 1040 1041
	}
	else if (openair0_cfg[0].clock_source==gpsdo) {
	  s->usrp->set_clock_source("gpsdo");
1042
	  LOG_I(HW,"Setting clock source to gpsdo\n");
1043
	}
1044
	else {
1045
	  LOG_W(HW,"Clock source set neither in usrp_args nor on command line, using default!\n");
1046
	}
1047 1048
    }
    else {
1049 1050
	if (openair0_cfg[0].clock_source != unset) {
	  LOG_W(HW,"Clock source set in both usrp_args and in clock_source, ingnoring the latter!\n");
1051
	}
1052
  }
laurent's avatar
laurent committed
1053

1054 1055 1056
    if (args.find("time_source")==std::string::npos) {
	if (openair0_cfg[0].time_source == internal) {
	  s->usrp->set_time_source("internal");
1057
	  LOG_I(HW,"Setting time source to internal\n");
1058 1059 1060
	}
	else if (openair0_cfg[0].time_source == external ) {
	  s->usrp->set_time_source("external");
1061
	  LOG_I(HW,"Setting time source to external\n");
1062 1063 1064
	}
	else if (openair0_cfg[0].time_source==gpsdo) {
	  s->usrp->set_time_source("gpsdo");
1065
	  LOG_I(HW,"Setting time source to gpsdo\n");
1066
	}
1067
	else {
1068 1069
	  LOG_W(HW,"Time source set neither in usrp_args nor on command line, using default!\n");
	}
1070
    }
1071 1072 1073 1074 1075
    else {
	if (openair0_cfg[0].clock_source != unset) {
	  LOG_W(HW,"Time source set in both usrp_args and in time_source, ingnoring the latter!\n");
	}
  }
1076

1077

1078 1079
  if (s->usrp->get_clock_source(0) == "gpsdo") {
    s->use_gps = 1;
1080

1081 1082 1083 1084 1085
    if (sync_to_gps(device)==EXIT_SUCCESS) {
      LOG_I(HW,"USRP synced with GPS!\n");
    } else {
      LOG_I(HW,"USRP fails to sync with GPS. Exiting.\n");
      exit(EXIT_FAILURE);
1086
    }
1087 1088 1089 1090 1091 1092 1093 1094
  } else if (s->usrp->get_clock_source(0) == "external") {
    if (check_ref_locked(s,0)) {
      LOG_I(HW,"USRP locked to external reference!\n");
    } else {
      LOG_I(HW,"Failed to lock to external reference. Exiting.\n");
      exit(EXIT_FAILURE);
    }
  }
1095

1096 1097
  if (device->type==USRP_X300_DEV) {
    openair0_cfg[0].rx_gain_calib_table = calib_table_x310;
1098
    std::cerr << "-- Using calibration table: calib_table_x310" << std::endl;
Raymond Knopp's avatar
Raymond Knopp committed
1099
    s->usrp->set_rx_dc_offset(true);
1100 1101 1102 1103
  }

  if (device->type==USRP_N300_DEV) {
    openair0_cfg[0].rx_gain_calib_table = calib_table_n310;
1104
    std::cerr << "-- Using calibration table: calib_table_n310" << std::endl;
1105 1106 1107 1108
  }


  if (device->type==USRP_N300_DEV || device->type==USRP_X300_DEV) {
1109
    LOG_I(HW,"%s() sample_rate:%u\n", __FUNCTION__, (int)openair0_cfg[0].sample_rate);
1110

1111 1112 1113 1114 1115 1116 1117 1118
    switch ((int)openair0_cfg[0].sample_rate) {
      case 122880000:
        // from usrp_time_offset
        //openair0_cfg[0].samples_per_packet    = 2048;
        openair0_cfg[0].tx_sample_advance     = 15; //to be checked
        openair0_cfg[0].tx_bw                 = 80e6;
        openair0_cfg[0].rx_bw                 = 80e6;
        break;
1119

1120 1121 1122 1123 1124 1125 1126
      case 92160000:
        // from usrp_time_offset
        //openair0_cfg[0].samples_per_packet    = 2048;
        openair0_cfg[0].tx_sample_advance     = 15; //to be checked
        openair0_cfg[0].tx_bw                 = 80e6;
        openair0_cfg[0].rx_bw                 = 80e6;
        break;
1127

1128 1129 1130 1131 1132 1133 1134
      case 61440000:
        // from usrp_time_offset
        //openair0_cfg[0].samples_per_packet    = 2048;
        openair0_cfg[0].tx_sample_advance     = 15;
        openair0_cfg[0].tx_bw                 = 40e6;
        openair0_cfg[0].rx_bw                 = 40e6;
        break;
1135

1136 1137
      case 46080000:
        //openair0_cfg[0].samples_per_packet    = 2048;
1138
        openair0_cfg[0].tx_sample_advance     = 15;
1139 1140 1141
        openair0_cfg[0].tx_bw                 = 40e6;
        openair0_cfg[0].rx_bw                 = 40e6;
        break;
1142

1143 1144 1145 1146 1147 1148 1149
      case 30720000:
        // from usrp_time_offset
        //openair0_cfg[0].samples_per_packet    = 2048;
        openair0_cfg[0].tx_sample_advance     = 15;
        openair0_cfg[0].tx_bw                 = 20e6;
        openair0_cfg[0].rx_bw                 = 20e6;
        break;
1150

1151 1152
      case 15360000:
        //openair0_cfg[0].samples_per_packet    = 2048;
1153
        openair0_cfg[0].tx_sample_advance     = 45;
1154 1155 1156
        openair0_cfg[0].tx_bw                 = 10e6;
        openair0_cfg[0].rx_bw                 = 10e6;
        break;
1157

1158 1159 1160 1161 1162 1163
      case 7680000:
        //openair0_cfg[0].samples_per_packet    = 2048;
        openair0_cfg[0].tx_sample_advance     = 50;
        openair0_cfg[0].tx_bw                 = 5e6;
        openair0_cfg[0].rx_bw                 = 5e6;
        break;
1164

1165 1166 1167 1168 1169 1170
      case 1920000:
        //openair0_cfg[0].samples_per_packet    = 2048;
        openair0_cfg[0].tx_sample_advance     = 50;
        openair0_cfg[0].tx_bw                 = 1.25e6;
        openair0_cfg[0].rx_bw                 = 1.25e6;
        break;
1171

1172 1173
      default:
        LOG_E(HW,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
1174
        exit(-1);
1175
        break;
1176 1177
    }
  }
1178

1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
  if (device->type == USRP_B200_DEV) {
    if ((vers == 3) && (subvers == 9) && (subsubvers>=2)) {
      openair0_cfg[0].rx_gain_calib_table = calib_table_b210;
      bw_gain_adjust=0;
      std::cerr << "-- Using calibration table: calib_table_b210" << std::endl; // Bell Labs info
    } else {
      openair0_cfg[0].rx_gain_calib_table = calib_table_b210_38;
      bw_gain_adjust=1;
      std::cerr << "-- Using calibration table: calib_table_b210_38" << std::endl; // Bell Labs info
    }
1189

1190 1191 1192 1193 1194 1195 1196 1197
    switch ((int)openair0_cfg[0].sample_rate) {
      case 46080000:
        s->usrp->set_master_clock_rate(46.08e6);
        //openair0_cfg[0].samples_per_packet    = 1024;
        openair0_cfg[0].tx_sample_advance     = 115;
        openair0_cfg[0].tx_bw                 = 40e6;
        openair0_cfg[0].rx_bw                 = 40e6;
        break;
1198

1199 1200 1201 1202 1203 1204 1205
      case 30720000:
        s->usrp->set_master_clock_rate(30.72e6);
        //openair0_cfg[0].samples_per_packet    = 1024;
        openair0_cfg[0].tx_sample_advance     = 115;
        openair0_cfg[0].tx_bw                 = 20e6;
        openair0_cfg[0].rx_bw                 = 20e6;
        break;
1206

1207 1208 1209 1210 1211 1212 1213
      case 23040000:
        s->usrp->set_master_clock_rate(23.04e6); //to be checked
        //openair0_cfg[0].samples_per_packet    = 1024;
        openair0_cfg[0].tx_sample_advance     = 113;
        openair0_cfg[0].tx_bw                 = 20e6;
        openair0_cfg[0].rx_bw                 = 20e6;
        break;
1214

1215 1216 1217 1218 1219 1220 1221
      case 15360000:
        s->usrp->set_master_clock_rate(30.72e06);
        //openair0_cfg[0].samples_per_packet    = 1024;
        openair0_cfg[0].tx_sample_advance     = 103;
        openair0_cfg[0].tx_bw                 = 20e6;
        openair0_cfg[0].rx_bw                 = 20e6;
        break;
1222

1223 1224 1225 1226 1227 1228 1229
      case 7680000:
        s->usrp->set_master_clock_rate(30.72e6);
        //openair0_cfg[0].samples_per_packet    = 1024;
        openair0_cfg[0].tx_sample_advance     = 80;
        openair0_cfg[0].tx_bw                 = 20e6;
        openair0_cfg[0].rx_bw                 = 20e6;
        break;
1230

1231 1232 1233 1234 1235 1236 1237
      case 1920000:
        s->usrp->set_master_clock_rate(30.72e6);
        //openair0_cfg[0].samples_per_packet    = 1024;
        openair0_cfg[0].tx_sample_advance     = 40;
        openair0_cfg[0].tx_bw                 = 20e6;
        openair0_cfg[0].rx_bw                 = 20e6;
        break;
1238

1239 1240 1241 1242
      default:
        LOG_E(HW,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
        exit(-1);
        break;
laurent's avatar
laurent committed
1243
    }
1244
  }
1245

1246 1247 1248 1249 1250
  /* device specific */
  //openair0_cfg[0].txlaunch_wait = 1;//manage when TX processing is triggered
  //openair0_cfg[0].txlaunch_wait_slotcount = 1; //manage when TX processing is triggered
  openair0_cfg[0].iq_txshift = 4;//shift
  openair0_cfg[0].iq_rxrescale = 15;//rescale iqs
1251

1252 1253
  for(int i=0; i<((int) s->usrp->get_rx_num_channels()); i++) {
    if (i<openair0_cfg[0].rx_num_channels) {
1254 1255
      s->usrp->set_rx_rate(openair0_cfg[0].sample_rate,i+choffset);
      s->usrp->set_rx_freq(openair0_cfg[0].rx_freq[i],i+choffset);
1256
      set_rx_gain_offset(&openair0_cfg[0],i,bw_gain_adjust);
1257
      ::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(i+choffset);
1258
      // limit to maximum gain
1259 1260 1261 1262 1263 1264
      double gain=openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i];
      if ( gain > gain_range.stop())  {
                   LOG_E(HW,"RX Gain too high, lower by %f dB\n",
                   gain - gain_range.stop());
               gain=gain_range.stop();
      }
1265

1266
      s->usrp->set_rx_gain(gain,i+choffset);
1267 1268 1269 1270 1271
      LOG_I(HW,"RX Gain %d %f (%f) => %f (max %f)\n",i,
            openair0_cfg[0].rx_gain[i],openair0_cfg[0].rx_gain_offset[i],
            openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],gain_range.stop());
    }
  }
1272

1273 1274
  LOG_D(HW, "usrp->get_tx_num_channels() == %zd\n", s->usrp->get_tx_num_channels());
  LOG_D(HW, "openair0_cfg[0].tx_num_channels == %d\n", openair0_cfg[0].tx_num_channels);
1275

1276 1277
  for(int i=0; i<((int) s->usrp->get_tx_num_channels()); i++) {
    ::uhd::gain_range_t gain_range_tx = s->usrp->get_tx_gain_range(i);
1278

1279
    if (i<openair0_cfg[0].tx_num_channels) {
1280 1281 1282
      s->usrp->set_tx_rate(openair0_cfg[0].sample_rate,i+choffset);
      s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[i],i+choffset);
      s->usrp->set_tx_gain(gain_range_tx.stop()-openair0_cfg[0].tx_gain[i],i+choffset);
1283 1284 1285
      LOG_I(HW,"USRP TX_GAIN:%3.2lf gain_range:%3.2lf tx_gain:%3.2lf\n", gain_range_tx.stop()-openair0_cfg[0].tx_gain[i], gain_range_tx.stop(), openair0_cfg[0].tx_gain[i]);
    }
  }
1286

1287 1288 1289 1290
  //s->usrp->set_clock_source("external");
  //s->usrp->set_time_source("external");
  // display USRP settings
  LOG_I(HW,"Actual master clock: %fMHz...\n",s->usrp->get_master_clock_rate()/1e6);
1291 1292 1293
  LOG_I(HW,"Actual clock source %s...\n",s->usrp->get_clock_source(0).c_str());
  LOG_I(HW,"Actual time source %s...\n",s->usrp->get_time_source(0).c_str());
   sleep(1);
1294 1295 1296 1297 1298 1299
  // create tx & rx streamer
  uhd::stream_args_t stream_args_rx("sc16", "sc16");
  int samples=openair0_cfg[0].sample_rate;
  int max=s->usrp->get_rx_stream(stream_args_rx)->get_max_num_samps();
  samples/=10000;
  LOG_I(HW,"RF board max packet size %u, size for 100µs jitter %d \n", max, samples);
1300

1301 1302 1303
  if ( samples < max ) {
    stream_args_rx.args["spp"] = str(boost::format("%d") % samples );
  }
1304

1305 1306
  LOG_I(HW,"rx_max_num_samps %zu\n",
        s->usrp->get_rx_stream(stream_args_rx)->get_max_num_samps());
1307

1308
  for (int i = 0; i<openair0_cfg[0].rx_num_channels; i++) {
1309 1310
    LOG_I(HW,"setting rx channel %d\n",i+choffset);
    stream_args_rx.channels.push_back(i+choffset);
1311
  }
1312

1313 1314
  s->rx_stream = s->usrp->get_rx_stream(stream_args_rx);
  uhd::stream_args_t stream_args_tx("sc16", "sc16");
1315

1316
  for (int i = 0; i<openair0_cfg[0].tx_num_channels; i++)
1317
    stream_args_tx.channels.push_back(i+choffset);
1318

1319
  s->tx_stream = s->usrp->get_tx_stream(stream_args_tx);
1320

1321 1322
  /* Setting TX/RX BW after streamers are created due to USRP calibration issue */
  for(int i=0; i<((int) s->usrp->get_tx_num_channels()) && i<openair0_cfg[0].tx_num_channels; i++)
1323
    s->usrp->set_tx_bandwidth(openair0_cfg[0].tx_bw,i+choffset);
1324

1325
  for(int i=0; i<((int) s->usrp->get_rx_num_channels()) && i<openair0_cfg[0].rx_num_channels; i++)
1326
    s->usrp->set_rx_bandwidth(openair0_cfg[0].rx_bw,i+choffset);
1327

1328 1329
  for (int i=0; i<openair0_cfg[0].rx_num_channels; i++) {
    LOG_I(HW,"RX Channel %d\n",i);
1330 1331 1332 1333 1334
    LOG_I(HW,"  Actual RX sample rate: %fMSps...\n",s->usrp->get_rx_rate(i+choffset)/1e6);
    LOG_I(HW,"  Actual RX frequency: %fGHz...\n", s->usrp->get_rx_freq(i+choffset)/1e9);
    LOG_I(HW,"  Actual RX gain: %f...\n", s->usrp->get_rx_gain(i+choffset));
    LOG_I(HW,"  Actual RX bandwidth: %fM...\n", s->usrp->get_rx_bandwidth(i+choffset)/1e6);
    LOG_I(HW,"  Actual RX antenna: %s...\n", s->usrp->get_rx_antenna(i+choffset).c_str());
1335
  }
1336

1337 1338
  for (int i=0; i<openair0_cfg[0].tx_num_channels; i++) {
    LOG_I(HW,"TX Channel %d\n",i);
1339 1340 1341 1342 1343
    LOG_I(HW,"  Actual TX sample rate: %fMSps...\n", s->usrp->get_tx_rate(i+choffset)/1e6);
    LOG_I(HW,"  Actual TX frequency: %fGHz...\n", s->usrp->get_tx_freq(i+choffset)/1e9);
    LOG_I(HW,"  Actual TX gain: %f...\n", s->usrp->get_tx_gain(i+choffset));
    LOG_I(HW,"  Actual TX bandwidth: %fM...\n", s->usrp->get_tx_bandwidth(i+choffset)/1e6);
    LOG_I(HW,"  Actual TX antenna: %s...\n", s->usrp->get_tx_antenna(i+choffset).c_str());
1344 1345
    LOG_I(HW,"  Actual TX packet size: %lu\n",s->tx_stream->get_max_num_samps());
  }
1346

1347 1348 1349 1350
  LOG_I(HW,"Device timestamp: %f...\n", s->usrp->get_time_now().get_real_secs());
  device->trx_write_func = trx_usrp_write;
  device->trx_read_func  = trx_usrp_read;
  s->sample_rate = openair0_cfg[0].sample_rate;
1351

1352 1353 1354 1355
  // TODO:
  // init tx_forward_nsamps based usrp_time_offset ex
  if(is_equal(s->sample_rate, (double)30.72e6))
    s->tx_forward_nsamps  = 176;
1356

1357 1358
  if(is_equal(s->sample_rate, (double)15.36e6))
    s->tx_forward_nsamps = 90;
1359

1360 1361
  if(is_equal(s->sample_rate, (double)7.68e6))
    s->tx_forward_nsamps = 50;
1362

1363
  recplay_state_t *recPlay=device->recplay_state;
1364

1365 1366
  if (recPlay != NULL) { // record mode
    recPlay->maxSizeBytes=openair0_cfg[0].recplay_conf->u_sf_max *
1367
                            (sizeof(iqrec_t)+BELL_LABS_IQ_BYTES_PER_SF);
1368 1369
    recPlay->ms_sample = (iqrec_t *) malloc(recPlay->maxSizeBytes);
    recPlay->currentPtr= (uint8_t *)recPlay->ms_sample;
1370

1371
    if (recPlay->ms_sample == NULL) {
1372 1373 1374 1375 1376
      std::cerr<< "Memory allocation failed for subframe record or replay mode." << std::endl;
      exit(-1);
    }
  }
  return 0;
Raymond Knopp's avatar
 
Raymond Knopp committed
1377
}
1378
/*@}*/
1379
}/* extern c */