usrp_lib.cpp 47.7 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[8][nsamps2];
389
  #else
390
    nsamps2 = (nsamps+3)>>2;
391
    __m128i buff_tx[8][nsamps2];
392
  #endif
393
#elif defined(__arm__)
394
    nsamps2 = (nsamps+3)>>2;
395
    int16x8_t buff_tx[8][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 467 468
    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;
    pthread_cond_signal(&write_thread->cond_write);
    pthread_mutex_unlock(&write_thread->mutex_write);
469
    return 0;
470
  }
WANG Tsu-Han's avatar
WANG Tsu-Han committed
471 472 473 474 475 476 477 478 479 480 481 482

}

//-----------------------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
*/
483
void *trx_usrp_write_thread(void * arg){
WANG Tsu-Han's avatar
WANG Tsu-Han committed
484 485 486 487 488
  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
489 490 491 492 493 494 495 496 497 498
  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
499 500 501

  while(1){
    pthread_mutex_lock(&write_thread->mutex_write);
WANG Tsu-Han's avatar
WANG Tsu-Han committed
502
    while (write_thread->count_write == 0) {
WANG Tsu-Han's avatar
WANG Tsu-Han committed
503 504
      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
505
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_THREAD, 1 );
506 507 508 509 510 511 512 513
    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
514
    flags_msb    = write_package[start].flags_msb;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
515 516
    write_thread->start = (write_thread->start + 1)% MAX_WRITE_THREAD_PACKAGE;
    write_thread->count_write--;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
517
    pthread_mutex_unlock(&write_thread->mutex_write);
518
    /*if(write_thread->count_write != 0){
WANG Tsu-Han's avatar
WANG Tsu-Han committed
519
      LOG_W(HW,"count write = %d, start = %d, end = %d\n", write_thread->count_write, write_thread->start, write_thread->end);
520
    }*/
WANG Tsu-Han's avatar
WANG Tsu-Han committed
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550

    #if defined(__x86_64) || defined(__i386__)
      #ifdef __AVX2__
        nsamps2 = (nsamps+7)>>3;
        __m256i buff_tx[8][nsamps2];
      #else
        nsamps2 = (nsamps+3)>>2;
        __m128i buff_tx[8][nsamps2];
      #endif
    #elif defined(__arm__)
      nsamps2 = (nsamps+3)>>2;
      int16x8_t buff_tx[8][nsamps2];
    #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
      }
    }
551

552

Raymond Knopp's avatar
Raymond Knopp committed
553
    s->tx_md.has_time_spec  = true;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
554 555
    s->tx_md.start_of_burst = (s->tx_count==0) ? true : first_packet;
    s->tx_md.end_of_burst   = last_packet;
556
    s->tx_md.time_spec      = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate);
557
    s->tx_count++;
558

559 560 561 562 563 564 565 566 567
    // 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();
    }

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

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

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

WANG Tsu-Han's avatar
WANG Tsu-Han committed
580
    if (ret != nsamps) LOG_E(HW,"[xmit] tx samples %d != %d\n",ret,nsamps);
WANG Tsu-Han's avatar
WANG Tsu-Han committed
581 582
    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 );
583

WANG Tsu-Han's avatar
WANG Tsu-Han committed
584
    if(0) break;
585
  }
586

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

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

Laurent OpenCells's avatar
Laurent OpenCells committed
592
  //uhd::set_thread_priority_safe(1.0);
WANG Tsu-Han's avatar
WANG Tsu-Han committed
593 594 595 596 597
  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
598
  write_thread->count_write        = 0;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
599
  printf("end of tx write thread\n");
600 601
  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
602 603 604 605 606 607 608
  pthread_create(&write_thread->pthread_write,NULL,trx_usrp_write_thread,(void *)device);

  return(0);
}

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

609 610 611 612 613 614 615 616 617 618 619
/*! \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
620
static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
621
  usrp_state_t *s = (usrp_state_t *)device->priv;
622
  int samples_received=0;
623
  int nsamps2;  // aligned to upper 32 or 16 byte boundary
624 625
#if defined(__x86_64) || defined(__i386__)
#ifdef __AVX2__
626 627
  nsamps2 = (nsamps+7)>>3;
  __m256i buff_tmp[2][nsamps2];
628
#else
629 630
  nsamps2 = (nsamps+3)>>2;
  __m128i buff_tmp[2][nsamps2];
631 632
#endif
#elif defined(__arm__)
633 634
  nsamps2 = (nsamps+3)>>2;
  int16x8_t buff_tmp[2][nsamps2];
635 636
#endif

637 638 639
    if (cc>1) {
      // receive multiple channels (e.g. RF A and RF B)
      std::vector<void *> buff_ptrs;
640

641
      for (int i=0; i<cc; i++) buff_ptrs.push_back(buff_tmp[i]);
642

643
      samples_received = s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md);
bruno mongazon-cazavet's avatar
bruno mongazon-cazavet committed
644
    } else {
645 646
      // receive a single channel (e.g. from connector RF A)
      samples_received=0;
647

648
      while (samples_received != nsamps) {
649
        samples_received += s->rx_stream->recv((void*)((int32_t*)buff_tmp[0]+samples_received),
650
                                               nsamps-samples_received, s->rx_md);
651

652 653
        if  ((s->wait_for_first_pps == 0) && (s->rx_md.error_code!=uhd::rx_metadata_t::ERROR_CODE_NONE))
          break;
654

655 656
        if ((s->wait_for_first_pps == 1) && (samples_received != nsamps)) {
          printf("sleep...\n"); //usleep(100);
laurent's avatar
laurent committed
657
        }
658
      }
659 660 661 662 663 664
      if (samples_received == nsamps) s->wait_for_first_pps=0;
    }

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

669 670 671 672 673
        if ((((uintptr_t) buff[i])&0x1F)==0) {
          ((__m256i *)buff[i])[j] = _mm256_srai_epi16(buff_tmp[i][j],4);
        } else {
          ((__m128i *)buff[i])[2*j] = _mm_srai_epi16(((__m128i *)buff_tmp[i])[2*j],4);
          ((__m128i *)buff[i])[2*j+1] = _mm_srai_epi16(((__m128i *)buff_tmp[i])[2*j+1],4);
674 675
        }

676
#else
677
        ((__m128i *)buff[i])[j] = _mm_srai_epi16(buff_tmp[i][j],4);
678 679
#endif
#elif defined(__arm__)
680
        ((int16x8_t *)buff[i])[j] = vshrq_n_s16(buff_tmp[i][j],4);
681
#endif
bruno mongazon-cazavet's avatar
bruno mongazon-cazavet committed
682
      }
683
    }
684

685 686
    if (samples_received < nsamps) {
      LOG_E(HW,"[recv] received %d samples out of %d\n",samples_received,nsamps);
687
    }
688

689 690
  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());
691

692 693 694
  s->rx_count += nsamps;
  s->rx_timestamp = s->rx_md.time_spec.to_ticks(s->sample_rate);
  *ptimestamp = s->rx_timestamp;
695

Rakesh's avatar
Rakesh committed
696
  // push GPIO bits 7-9 from flags_msb
Rakesh's avatar
Rakesh committed
697
   /*s->usrp->set_command_time(uhd::time_spec_t::from_ticks((s->rx_timestamp+(2*nsamps)),s->sample_rate));
Rakesh's avatar
Rakesh committed
698 699
   s->usrp->set_gpio_attr("FP0", "OUT", gpio789<<7, 0x380);
   s->usrp->clear_command_time();
Rakesh's avatar
Rakesh committed
700
   gpio789 = (gpio789+1)&7;*/
701
  recplay_state_t *recPlay=device->recplay_state;
Rakesh's avatar
Rakesh committed
702

703
  if ( recPlay != NULL) { // record mode
704
    // Copy subframes to memory (later dump on a file)
705 706 707 708 709 710 711 712 713 714 715 716 717
    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");
718
  }
719

720
  return samples_received;
Raymond Knopp's avatar
 
Raymond Knopp committed
721 722
}

723 724 725 726
/*! \brief Compares two variables within precision
 * \param a first variable
 * \param b second variable
*/
laurent's avatar
laurent committed
727
static bool is_equal(double a, double b) {
728
  return std::fabs(a-b) < std::numeric_limits<double>::epsilon();
Raymond Knopp's avatar
 
Raymond Knopp committed
729
}
Raymond Knopp's avatar
 
Raymond Knopp committed
730

731
void *freq_thread(void *arg) {
732 733 734 735
  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]);
736
  return NULL;
737 738
}
/*! \brief Set frequencies (TX/RX). Spawns a thread to handle the frequency change to not block the calling thread
739 740 741
 * \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
742
 * \returns 0 in success
743
 */
744 745 746 747 748 749 750 751 752 753 754 755
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
756

757
  return(0);
Raymond Knopp's avatar
 
Raymond Knopp committed
758 759
}

laurent's avatar
laurent committed
760
/*! \brief Set RX frequencies
761 762
 * \param device the hardware to use
 * \param openair0_cfg RF frontend parameters set by application
laurent's avatar
laurent committed
763
 * \returns 0 in success
764
 */
765 766 767 768 769 770 771
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
772 773
}

774 775 776
/*! \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
777
 * \returns 0 in success
778
 */
779
int trx_usrp_set_gains(openair0_device *device,
laurent's avatar
laurent committed
780
                       openair0_config_t *openair0_cfg) {
781 782 783 784 785 786 787
  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()) {
788
    LOG_E(HW,"RX Gain 0 too high, reduce by %f dB\n",
789 790 791
          openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0] - gain_range.stop());
    exit(-1);
  }
laurent's avatar
laurent committed
792

793
  s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[0]-openair0_cfg[0].rx_gain_offset[0]);
794
  LOG_I(HW,"Setting USRP RX gain to %f (rx_gain %f,gain_range.stop() %f)\n",
795 796 797
        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
798
}
799

800 801 802
/*! \brief Stop USRP
 * \param card refers to the hardware index to use
 */
803 804
int trx_usrp_stop(openair0_device *device) {
  return(0);
805
}
806

807
/*! \brief USRPB210 RX calibration table */
808
rx_gain_calib_table_t calib_table_b210[] = {
809 810 811 812 813 814
  {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
815
};
816

817
/*! \brief USRPB210 RX calibration table */
818
rx_gain_calib_table_t calib_table_b210_38[] = {
819 820 821 822 823 824
  {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
825
};
826

827
/*! \brief USRPx310 RX calibration table */
828
rx_gain_calib_table_t calib_table_x310[] = {
829 830 831 832 833 834
  {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
835 836
};

837 838 839 840 841 842 843 844 845 846 847
/*! \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
848
/*! \brief Set RX gain offset
849 850
 * \param openair0_cfg RF frontend parameters set by application
 * \param chain_index RF chain to apply settings to
laurent's avatar
laurent committed
851
 * \returns 0 in success
852
 */
853
void set_rx_gain_offset(openair0_config_t *openair0_cfg, int chain_index,int bw_gain_adjust) {
854 855 856
  int i=0;
  // loop through calibration table to find best adjustment factor for RX frequency
  double min_diff = 6e9,diff,gain_adj=0.0;
857

858 859
  if (bw_gain_adjust==1) {
    switch ((int)openair0_cfg[0].sample_rate) {
860 861 862
      case 46080000:
        break;

863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
      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:
887
        LOG_E(HW,"unknown sampling rate %d\n",(int)openair0_cfg[0].sample_rate);
888
        //exit(-1);
889
        break;
890
    }
891 892 893 894
  }

  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);
895
    LOG_I(HW,"cal %d: freq %f, offset %f, diff %f\n",
896 897 898 899 900 901 902
          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
903
    }
904 905 906

    i++;
  }
907 908
}

laurent's avatar
laurent committed
909
/*! \brief print the USRP statistics
910 911 912
* \param device the hardware to use
* \returns  0 on success
*/
913 914
int trx_usrp_get_stats(openair0_device *device) {
  return(0);
915
}
916

laurent's avatar
laurent committed
917 918 919 920
/*! \brief Reset the USRP statistics
 * \param device the hardware to use
 * \returns  0 on success
 */
921 922
int trx_usrp_reset_stats(openair0_device *device) {
  return(0);
923
}
924

925
extern "C" {
926
  int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
927 928 929 930 931 932 933 934 935 936
    LOG_D(HW, "openair0_cfg[0].sdr_addrs == '%s'\n", openair0_cfg[0].sdr_addrs);
    LOG_D(HW, "openair0_cfg[0].clock_source == '%d'\n", openair0_cfg[0].clock_source);
    usrp_state_t *s ;

    if ( device->priv == NULL) {
      s=(usrp_state_t *)calloc(sizeof(usrp_state_t),1);
      device->priv=s;
      AssertFatal( s!=NULL,"USRP device: memory allocation failure\n");
    } else {
      LOG_E(HW, "multiple device init detected\n");
937 938 939
      return 0;
    }

940 941 942 943 944 945 946 947
    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;
948
    device->trx_write_init = trx_usrp_write_init;
949 950


951
    // hotfix! to be checked later
Laurent OpenCells's avatar
Laurent OpenCells committed
952
    //uhd::set_thread_priority_safe(1.0);
953 954 955
    // Initialize USRP device
    int vers=0,subvers=0,subsubvers=0;
    int bw_gain_adjust=0;
956

957 958
    if (device->openair0_cfg->recplay_mode == RECPLAY_RECORDMODE) {
      std::cerr << "USRP device initialized in subframes record mode" << std::endl;
959
    }
960

961 962 963 964
    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;
965

966 967
    if (openair0_cfg[0].sdr_addrs == NULL) {
      args = "type=b200";
968
    } else {
969 970 971
      args = openair0_cfg[0].sdr_addrs;
      LOG_I(HW,"Checking for USRP with args %s\n",openair0_cfg[0].sdr_addrs);
    }
972

973
    uhd::device_addrs_t device_adds = uhd::device::find(args);
974

975 976 977 978 979 980 981 982 983
    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;
    }
984

985 986
    LOG_I(HW,"Found USRP %s\n", device_adds[0].get("type").c_str());
    double usrp_master_clock;
987

988 989 990 991 992 993
    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" ;
    }
994

995 996
    if (device_adds[0].get("type") == "n3xx") {
      printf("Found USRP n300\n");
997
      device->type=USRP_N300_DEV;
998 999 1000 1001
      usrp_master_clock = 122.88e6;
      args += boost::str(boost::format(",master_clock_rate=%f") % usrp_master_clock);
      //args += ", send_buff_size=33554432";
    }
1002

1003 1004 1005 1006 1007
    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);
1008

1009 1010 1011 1012
      // 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");
    }
1013

1014
    s->usrp = uhd::usrp::multi_usrp::make(args);
1015

1016
    if (args.find("clock_source")==std::string::npos) {
1017 1018
	if (openair0_cfg[0].clock_source == internal) {
	  s->usrp->set_clock_source("internal");
1019
	  LOG_D(HW,"Setting clock source to internal\n");
1020 1021 1022
	}
	else if (openair0_cfg[0].clock_source == external ) {
	  s->usrp->set_clock_source("external");
1023
	  LOG_D(HW,"Setting clock source to external\n");
1024 1025 1026
	}
	else if (openair0_cfg[0].clock_source==gpsdo) {
	  s->usrp->set_clock_source("gpsdo");
1027
	  LOG_D(HW,"Setting clock source to gpsdo\n");
1028
	}
1029
	else {
1030
	  LOG_W(HW,"Clock source set neither in usrp_args nor on command line, using default!\n");
1031
	}
1032 1033
    }
    else {
1034 1035
	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");
1036
	}
1037
  }
laurent's avatar
laurent committed
1038

1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
    if (args.find("time_source")==std::string::npos) {
	if (openair0_cfg[0].time_source == internal) {
	  s->usrp->set_time_source("internal");
	  LOG_D(HW,"Setting time source to internal\n");
	}
	else if (openair0_cfg[0].time_source == external ) {
	  s->usrp->set_time_source("external");
	  LOG_D(HW,"Setting time source to external\n");
	}
	else if (openair0_cfg[0].time_source==gpsdo) {
	  s->usrp->set_time_source("gpsdo");
	  LOG_D(HW,"Setting time source to gpsdo\n");
	}
1052
	else {
1053 1054
	  LOG_W(HW,"Time source set neither in usrp_args nor on command line, using default!\n");
	}
1055
    }
1056 1057 1058 1059 1060
    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");
	}
  }
1061

1062

1063 1064
  if (s->usrp->get_clock_source(0) == "gpsdo") {
    s->use_gps = 1;
1065

1066 1067 1068 1069 1070
    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);
1071
    }
1072 1073 1074 1075 1076 1077 1078 1079
  } 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);
    }
  }
1080

1081 1082
  if (device->type==USRP_X300_DEV) {
    openair0_cfg[0].rx_gain_calib_table = calib_table_x310;
1083
    std::cerr << "-- Using calibration table: calib_table_x310" << std::endl;
1084 1085 1086 1087
  }

  if (device->type==USRP_N300_DEV) {
    openair0_cfg[0].rx_gain_calib_table = calib_table_n310;
1088
    std::cerr << "-- Using calibration table: calib_table_n310" << std::endl;
1089 1090 1091 1092
  }


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

1095 1096 1097 1098 1099 1100 1101 1102
    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;
1103

1104 1105 1106 1107 1108 1109 1110
      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;
1111

1112 1113 1114 1115 1116 1117 1118
      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;
1119

1120 1121
      case 46080000:
        //openair0_cfg[0].samples_per_packet    = 2048;
1122
        openair0_cfg[0].tx_sample_advance     = 15;
1123 1124 1125
        openair0_cfg[0].tx_bw                 = 40e6;
        openair0_cfg[0].rx_bw                 = 40e6;
        break;
1126

1127 1128 1129 1130 1131 1132 1133
      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;
1134

1135 1136
      case 15360000:
        //openair0_cfg[0].samples_per_packet    = 2048;
1137
        openair0_cfg[0].tx_sample_advance     = 45;
1138 1139 1140
        openair0_cfg[0].tx_bw                 = 10e6;
        openair0_cfg[0].rx_bw                 = 10e6;
        break;
1141

1142 1143 1144 1145 1146 1147
      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;
1148

1149 1150 1151 1152 1153 1154
      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;
1155

1156 1157
      default:
        LOG_E(HW,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
1158
        exit(-1);
1159
        break;
1160 1161
    }
  }
1162

1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
  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
    }
1173

1174 1175 1176 1177 1178 1179 1180 1181
    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;
1182

1183 1184 1185 1186 1187 1188 1189
      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;
1190

1191 1192 1193 1194 1195 1196 1197
      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;
1198

1199 1200 1201 1202 1203 1204 1205
      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;
1206

1207 1208 1209 1210 1211 1212 1213
      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;
1214

1215 1216 1217 1218 1219 1220 1221
      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;
1222

1223 1224 1225 1226
      default:
        LOG_E(HW,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
        exit(-1);
        break;
laurent's avatar
laurent committed
1227
    }
1228
  }
1229

1230 1231 1232 1233 1234
  /* 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
1235

1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
  for(int i=0; i<((int) s->usrp->get_rx_num_channels()); i++) {
    if (i<openair0_cfg[0].rx_num_channels) {
      s->usrp->set_rx_rate(openair0_cfg[0].sample_rate,i);
      s->usrp->set_rx_freq(openair0_cfg[0].rx_freq[i],i);
      set_rx_gain_offset(&openair0_cfg[0],i,bw_gain_adjust);
      ::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(i);
      // limit to maximum gain
      AssertFatal( openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] <= gain_range.stop(),
                   "RX Gain too high, lower by %f dB\n",
                   openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] - gain_range.stop());
      s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],i);
      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());
    }
  }
1252

1253 1254
  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);
1255

1256 1257
  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);
1258

1259 1260 1261 1262 1263 1264 1265
    if (i<openair0_cfg[0].tx_num_channels) {
      s->usrp->set_tx_rate(openair0_cfg[0].sample_rate,i);
      s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[i],i);
      s->usrp->set_tx_gain(gain_range_tx.stop()-openair0_cfg[0].tx_gain[i],i);
      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]);
    }
  }
1266

1267 1268 1269 1270
  //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);
1271 1272 1273
  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);
1274 1275 1276 1277 1278 1279
  // 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);
1280

1281 1282 1283
  if ( samples < max ) {
    stream_args_rx.args["spp"] = str(boost::format("%d") % samples );
  }
1284

1285 1286
  LOG_I(HW,"rx_max_num_samps %zu\n",
        s->usrp->get_rx_stream(stream_args_rx)->get_max_num_samps());
1287

1288 1289
  for (int i = 0; i<openair0_cfg[0].rx_num_channels; i++)
    stream_args_rx.channels.push_back(i);
1290

1291 1292
  s->rx_stream = s->usrp->get_rx_stream(stream_args_rx);
  uhd::stream_args_t stream_args_tx("sc16", "sc16");
1293

1294 1295
  for (int i = 0; i<openair0_cfg[0].tx_num_channels; i++)
    stream_args_tx.channels.push_back(i);
1296

1297
  s->tx_stream = s->usrp->get_tx_stream(stream_args_tx);
1298

1299 1300 1301
  /* 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++)
    s->usrp->set_tx_bandwidth(openair0_cfg[0].tx_bw,i);
1302

1303 1304
  for(int i=0; i<((int) s->usrp->get_rx_num_channels()) && i<openair0_cfg[0].rx_num_channels; i++)
    s->usrp->set_rx_bandwidth(openair0_cfg[0].rx_bw,i);
1305

1306 1307 1308 1309 1310 1311 1312 1313
  for (int i=0; i<openair0_cfg[0].rx_num_channels; i++) {
    LOG_I(HW,"RX Channel %d\n",i);
    LOG_I(HW,"  Actual RX sample rate: %fMSps...\n",s->usrp->get_rx_rate(i)/1e6);
    LOG_I(HW,"  Actual RX frequency: %fGHz...\n", s->usrp->get_rx_freq(i)/1e9);
    LOG_I(HW,"  Actual RX gain: %f...\n", s->usrp->get_rx_gain(i));
    LOG_I(HW,"  Actual RX bandwidth: %fM...\n", s->usrp->get_rx_bandwidth(i)/1e6);
    LOG_I(HW,"  Actual RX antenna: %s...\n", s->usrp->get_rx_antenna(i).c_str());
  }
1314

1315 1316 1317 1318 1319 1320 1321 1322 1323
  for (int i=0; i<openair0_cfg[0].tx_num_channels; i++) {
    LOG_I(HW,"TX Channel %d\n",i);
    LOG_I(HW,"  Actual TX sample rate: %fMSps...\n", s->usrp->get_tx_rate(i)/1e6);
    LOG_I(HW,"  Actual TX frequency: %fGHz...\n", s->usrp->get_tx_freq(i)/1e9);
    LOG_I(HW,"  Actual TX gain: %f...\n", s->usrp->get_tx_gain(i));
    LOG_I(HW,"  Actual TX bandwidth: %fM...\n", s->usrp->get_tx_bandwidth(i)/1e6);
    LOG_I(HW,"  Actual TX antenna: %s...\n", s->usrp->get_tx_antenna(i).c_str());
    LOG_I(HW,"  Actual TX packet size: %lu\n",s->tx_stream->get_max_num_samps());
  }
1324

1325 1326 1327 1328
  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;
1329

1330 1331 1332 1333
  // TODO:
  // init tx_forward_nsamps based usrp_time_offset ex
  if(is_equal(s->sample_rate, (double)30.72e6))
    s->tx_forward_nsamps  = 176;
1334

1335 1336
  if(is_equal(s->sample_rate, (double)15.36e6))
    s->tx_forward_nsamps = 90;
1337

1338 1339
  if(is_equal(s->sample_rate, (double)7.68e6))
    s->tx_forward_nsamps = 50;
1340

1341
  recplay_state_t *recPlay=device->recplay_state;
1342

1343 1344
  if (recPlay != NULL) { // record mode
    recPlay->maxSizeBytes=openair0_cfg[0].recplay_conf->u_sf_max *
1345
                            (sizeof(iqrec_t)+BELL_LABS_IQ_BYTES_PER_SF);
1346 1347
    recPlay->ms_sample = (iqrec_t *) malloc(recPlay->maxSizeBytes);
    recPlay->currentPtr= (uint8_t *)recPlay->ms_sample;
1348

1349
    if (recPlay->ms_sample == NULL) {
1350 1351 1352 1353 1354
      std::cerr<< "Memory allocation failed for subframe record or replay mode." << std::endl;
      exit(-1);
    }
  }
  return 0;
Raymond Knopp's avatar
 
Raymond Knopp committed
1355
}
1356
/*@}*/
1357
}/* extern c */