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
  s->usrp->set_gpio_attr("FP0", "OUT", 7<<7, 0xf80);
288

289 290 291 292 293 294
  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;
295

296 297 298 299 300
  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
static int trx_usrp_write(openair0_device *device,
335 336 337 338 339
			  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);
352 353 354 355 356 357 358 359 360 361 362 363 364 365

    boolean_t first_packet_state=false,last_packet_state=false;

    if (flags_lsb == 2) { // start of burst
      //      s->tx_md.start_of_burst = true;
      //      s->tx_md.end_of_burst = false;
      first_packet_state = true;
      last_packet_state  = false;
    } else if (flags_lsb == 3) { // end of burst
      //s->tx_md.start_of_burst = false;
      //s->tx_md.end_of_burst = true;
      first_packet_state = false;
      last_packet_state  = true;
    } else if (flags_lsb == 4) { // start and end
366 367
    //  s->tx_md.start_of_burst = true;
    //  s->tx_md.end_of_burst = true;
368 369 370
      first_packet_state = true;
      last_packet_state  = true;
    } else if (flags_lsb==1) { // middle of burst
371 372
    //  s->tx_md.start_of_burst = false;
    //  s->tx_md.end_of_burst = false;
373 374 375 376 377 378 379 380 381 382
      first_packet_state = false;
      last_packet_state  = false;
    }
    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;
    }
383

384
  if(usrp_tx_thread == 0){
385
#if defined(__x86_64) || defined(__i386__)
386 387 388 389
  #ifdef __AVX2__
      nsamps2 = (nsamps+7)>>3;
      __m256i buff_tx[8][nsamps2];
  #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

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
    }
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
    }
    else {
441 442 443
      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
  }
  else{
448
    pthread_mutex_lock(&write_thread->mutex_write);
449

450
    if(write_thread->count_write >= MAX_WRITE_THREAD_PACKAGE){
451 452 453
      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
  }
471

WANG Tsu-Han's avatar
WANG Tsu-Han committed
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
  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;
488

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
  while(1){
WANG Tsu-Han's avatar
WANG Tsu-Han committed
501
    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
    }*/
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535

    #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
WANG Tsu-Han's avatar
WANG Tsu-Han committed
536 537 538 539

    // bring RX data into 12 LSBs for softmodem RX
    for (int i=0; i<cc; i++) {
      for (int j=0; j<nsamps2; j++) {
540 541 542 543 544 545 546 547 548
        #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
WANG Tsu-Han's avatar
WANG Tsu-Han committed
549 550
      }
    }
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
    }
    else {
577 578
      ret = (int)s->tx_stream->send(&(((int16_t *)buff_tx[0])[0]), nsamps, s->tx_md);
    }
579

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

584
  }
585

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

589 590
int trx_usrp_write_init(openair0_device *device){

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

WANG Tsu-Han's avatar
WANG Tsu-Han committed
595 596
  write_thread->start              = 0;
  write_thread->end                = 0;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
597
  write_thread->count_write        = 0;
WANG Tsu-Han's avatar
WANG Tsu-Han committed
598
  printf("end of tx write thread\n");
599 600
  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
601
  pthread_create(&write_thread->pthread_write,NULL,trx_usrp_write_thread,(void *)device);
602

WANG Tsu-Han's avatar
WANG Tsu-Han committed
603 604 605 606 607
  return(0);
}

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

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

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

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

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

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

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

654 655 656
        if ((s->wait_for_first_pps == 1) && (samples_received != nsamps)) {
          printf("sleep...\n"); //usleep(100);
        }
657
      }
658
      if (samples_received == nsamps) s->wait_for_first_pps=0;
659 660
    }

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

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
#else
676
        ((__m128i *)buff[i])[j] = _mm_srai_epi16(buff_tmp[i][j],4);
677 678
#endif
#elif defined(__arm__)
679
        ((int16x8_t *)buff[i])[j] = vshrq_n_s16(buff_tmp[i][j],4);
680
#endif
681
      }
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
  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());
690

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    i++;
  }
906 907
}

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

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

924
extern "C" {
925
  int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
926 927
    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);
928 929 930 931 932 933 934 935
    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");
936 937 938
      return 0;
    }

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

1061

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

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

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

1085 1086 1087 1088
  if (device->type==USRP_N300_DEV) {
    openair0_cfg[0].rx_gain_calib_table = calib_table_n310;
    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) {
    LOG_I(HW,"%s() sample_rate:%u\n", __FUNCTION__, (int)openair0_cfg[0].sample_rate);
1093

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

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

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

1119 1120 1121 1122 1123 1124
      case 46080000:
        //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;
1125

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

1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
      case 15360000:
        //openair0_cfg[0].samples_per_packet    = 2048;
        openair0_cfg[0].tx_sample_advance     = 45;
        openair0_cfg[0].tx_bw                 = 10e6;
        openair0_cfg[0].rx_bw                 = 10e6;
        break;

      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;

      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;

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

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

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

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

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

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

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

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

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

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
  /* 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

  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());
laurent's avatar
laurent committed
1249
    }
1250
  }
1251

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

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

1258 1259 1260 1261 1262
    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]);
1263
    }
1264
  }
1265

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

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

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

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

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

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

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

1298 1299 1300
  /* 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);
1301

1302 1303
  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);
1304

1305 1306 1307 1308 1309 1310 1311 1312
  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());
  }
1313

1314 1315 1316 1317 1318 1319 1320 1321 1322
  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());
  }
1323

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

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

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

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

1340
  recplay_state_t *recPlay=device->recplay_state;
1341

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

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