lte-enb.c 70.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * 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
 * the OAI Public License, Version 1.0  (the "License"); you may not use this file
 * 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
 */
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

/*! \file lte-enb.c
 * \brief Top-level threads for eNodeB
 * \author R. Knopp, F. Kaltenberger, Navid Nikaein
 * \date 2012
 * \version 0.1
 * \company Eurecom
 * \email: knopp@eurecom.fr,florian.kaltenberger@eurecom.fr, navid.nikaein@eurecom.fr
 * \note
 * \warning
 */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sched.h>
#include <linux/sched.h>
#include <signal.h>
#include <execinfo.h>
#include <getopt.h>
#include <sys/sysinfo.h>
#include "rt_wrapper.h"

#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all

#include "assertions.h"
#include "msc.h"

#include "PHY/types.h"

#include "PHY/defs.h"
#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all

#include "../../ARCH/COMMON/common_lib.h"

//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all

63
#include "PHY/LTE_TRANSPORT/if4_tools.h"
64
#include "PHY/LTE_TRANSPORT/if5_tools.h"
65

66 67 68 69 70 71 72 73 74 75 76 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
#include "PHY/extern.h"
#include "SCHED/extern.h"
#include "LAYER2/MAC/extern.h"

#include "../../SIMU/USER/init_lte.h"

#include "LAYER2/MAC/defs.h"
#include "LAYER2/MAC/extern.h"
#include "LAYER2/MAC/proto.h"
#include "RRC/LITE/extern.h"
#include "PHY_INTERFACE/extern.h"

#ifdef SMBV
#include "PHY/TOOLS/smbv.h"
unsigned short config_frames[4] = {2,9,11,13};
#endif
#include "UTIL/LOG/log_extern.h"
#include "UTIL/OTG/otg_tx.h"
#include "UTIL/OTG/otg_externs.h"
#include "UTIL/MATH/oml.h"
#include "UTIL/LOG/vcd_signal_dumper.h"
#include "UTIL/OPT/opt.h"
#include "enb_config.h"
//#include "PHY/TOOLS/time_meas.h"

#ifndef OPENAIR2
#include "UTIL/OTG/otg_extern.h"
#endif

#if defined(ENABLE_ITTI)
# if defined(ENABLE_USE_MME)
#   include "s1ap_eNB.h"
#ifdef PDCP_USE_NETLINK
#   include "SIMULATION/ETH_TRANSPORT/proto.h"
#endif
# endif
#endif

Rohit Gupta's avatar
Rohit Gupta committed
104 105
#include "T.h"

106 107 108 109 110 111 112 113 114 115
//#define DEBUG_THREADS 1

//#define USRP_DEBUG 1
struct timing_info_t {
  //unsigned int frame, hw_slot, last_slot, next_slot;
  RTIME time_min, time_max, time_avg, time_last, time_now;
  //unsigned int mbox0, mbox1, mbox2, mbox_target;
  unsigned int n_samples;
} timing_info;

116 117
// Fix per CC openair rf/if device update
// extern openair0_device openair0;
118 119 120 121 122 123 124 125 126 127 128 129 130

#if defined(ENABLE_ITTI)
extern volatile int             start_eNB;
extern volatile int             start_UE;
#endif
extern volatile int                    oai_exit;

extern openair0_config_t openair0_cfg[MAX_CARDS];

extern pthread_cond_t sync_cond;
extern pthread_mutex_t sync_mutex;
extern int sync_var;

131 132
extern transmission_mode;

133
//pthread_t                       main_eNB_thread;
134 135 136

time_stats_t softmodem_stats_mt; // main thread
time_stats_t softmodem_stats_hw; //  hw acquisition
137
time_stats_t softmodem_stats_rxtx_sf; // total tx time
138
time_stats_t softmodem_stats_rx_sf; // total rx time
139 140
//int32_t **rxdata;
//int32_t **txdata;
141

142 143
uint8_t seqno; //sequence number

144 145 146 147 148 149 150 151 152 153
static int                      time_offset[4] = {0,0,0,0};

/* mutex, cond and variable to serialize phy proc TX calls
 * (this mechanism may be relaxed in the future for better
 * performances)
 */
static struct {
  pthread_mutex_t  mutex_phy_proc_tx;
  pthread_cond_t   cond_phy_proc_tx;
  volatile uint8_t phy_proc_CC_id;
154
} sync_phy_proc;
155

156 157
extern double cpuf;

158 159
void exit_fun(const char* s);

160
void init_eNB(eNB_func_t node_function[], eNB_timing_t node_timing[],int nb_inst,eth_params_t *,int,int);
161
void stop_eNB(int nb_inst);
162 163


Raymond Knopp's avatar
Raymond Knopp committed
164
static inline void thread_top_init(char *thread_name,
165
				   int affinity,
Raymond Knopp's avatar
Raymond Knopp committed
166 167 168
				   uint64_t runtime,
				   uint64_t deadline,
				   uint64_t period) {
Raymond Knopp's avatar
Raymond Knopp committed
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188

  MSC_START_USE();

#ifdef DEADLINE_SCHEDULER
  struct sched_attr attr;

  unsigned int flags = 0;

  attr.size = sizeof(attr);
  attr.sched_flags = 0;
  attr.sched_nice = 0;
  attr.sched_priority = 0;

  attr.sched_policy   = SCHED_DEADLINE;
  attr.sched_runtime  = runtime;
  attr.sched_deadline = deadline;
  attr.sched_period   = period; 

  if (sched_setattr(0, &attr, flags) < 0 ) {
    perror("[SCHED] eNB tx thread: sched_setattr failed\n");
laurent's avatar
laurent committed
189
    exit(1);
Raymond Knopp's avatar
Raymond Knopp committed
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
  }

#else //LOW_LATENCY
  int policy, s, j;
  struct sched_param sparam;
  char cpu_affinity[1024];
  cpu_set_t cpuset;

  /* Set affinity mask to include CPUs 1 to MAX_CPUS */
  /* CPU 0 is reserved for UHD threads */
  /* CPU 1 is reserved for all RX_TX threads */
  /* Enable CPU Affinity only if number of CPUs >2 */
  CPU_ZERO(&cpuset);

#ifdef CPU_AFFINITY
  if (get_nprocs() > 2)
  {
207 208 209 210
    if (affinity == 0)
      CPU_SET(0,&cpuset);
    else
      for (j = 1; j < get_nprocs(); j++)
Raymond Knopp's avatar
Raymond Knopp committed
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
        CPU_SET(j, &cpuset);
    s = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
    if (s != 0)
    {
      perror( "pthread_setaffinity_np");
      exit_fun("Error setting processor affinity");
    }
  }
#endif //CPU_AFFINITY

  /* Check the actual affinity mask assigned to the thread */
  s = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
  if (s != 0) {
    perror( "pthread_getaffinity_np");
    exit_fun("Error getting processor affinity ");
  }
  memset(cpu_affinity,0,sizeof(cpu_affinity));
  for (j = 0; j < CPU_SETSIZE; j++)
    if (CPU_ISSET(j, &cpuset)) {  
      char temp[1024];
      sprintf (temp, " CPU_%d", j);
      strcat(cpu_affinity, temp);
    }

  memset(&sparam, 0, sizeof(sparam));
236
  sparam.sched_priority = sched_get_priority_max(SCHED_FIFO);
Raymond Knopp's avatar
Raymond Knopp committed
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
  policy = SCHED_FIFO ; 
  
  s = pthread_setschedparam(pthread_self(), policy, &sparam);
  if (s != 0) {
    perror("pthread_setschedparam : ");
    exit_fun("Error setting thread priority");
  }
  
  s = pthread_getschedparam(pthread_self(), &policy, &sparam);
  if (s != 0) {
    perror("pthread_getschedparam : ");
    exit_fun("Error getting thread priority");
  }

  LOG_I(HW, "[SCHED][eNB] %s started on CPU %d TID %ld, sched_policy = %s , priority = %d, CPU Affinity=%s \n",thread_name,sched_getcpu(),gettid(),
                   (policy == SCHED_FIFO)  ? "SCHED_FIFO" :
                   (policy == SCHED_RR)    ? "SCHED_RR" :
                   (policy == SCHED_OTHER) ? "SCHED_OTHER" :
                   "???",
                   sparam.sched_priority, cpu_affinity );

#endif //LOW_LATENCY

  mlockall(MCL_CURRENT | MCL_FUTURE);

}

Raymond Knopp's avatar
Raymond Knopp committed
264
static inline void wait_sync(char *thread_name) {
Raymond Knopp's avatar
Raymond Knopp committed
265 266 267 268 269 270 271 272 273 274 275 276 277

  printf( "waiting for sync (%s)\n",thread_name);
  pthread_mutex_lock( &sync_mutex );
  
  while (sync_var<0)
    pthread_cond_wait( &sync_cond, &sync_mutex );
  
  pthread_mutex_unlock(&sync_mutex);
  
  printf( "got sync (%s)\n", thread_name);

}

278

279 280
void do_OFDM_mod_rt(int subframe,PHY_VARS_eNB *phy_vars_eNB)
{
281

282 283
  unsigned int aa,slot_offset;
  //int dummy_tx_b[7680*4] __attribute__((aligned(32)));
284
  int i, tx_offset;
285
  //int slot_sizeF = (phy_vars_eNB->frame_parms.ofdm_symbol_size)* ((phy_vars_eNB->frame_parms.Ncp==1) ? 6 : 7);
286
  int len;
287
  //int slot_offset_F = (subframe<<1)*slot_sizeF;
288

289
  slot_offset = subframe*phy_vars_eNB->frame_parms.samples_per_tti;
290

291
  
292 293
  if ((subframe_select(&phy_vars_eNB->frame_parms,subframe)==SF_DL)||
      ((subframe_select(&phy_vars_eNB->frame_parms,subframe)==SF_S))) {
294 295
    //    LOG_D(HW,"Frame %d: Generating slot %d\n",frame,next_slot);

296 297
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_OFDM_MODULATION,1);

298
    do_OFDM_mod_symbol(&phy_vars_eNB->common_vars,
299 300
                  0,
                  subframe<<1,
301 302
                  &phy_vars_eNB->frame_parms,
		  phy_vars_eNB->do_precoding);
303 304
 
    // if S-subframe generate first slot only 
305 306
    if (subframe_select(&phy_vars_eNB->frame_parms,subframe) == SF_DL) {
      do_OFDM_mod_symbol(&phy_vars_eNB->common_vars,
307 308
                    0,
                    1+(subframe<<1),
309 310
                    &phy_vars_eNB->frame_parms,
                    phy_vars_eNB->do_precoding);
311 312 313 314 315 316
    }

    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_OFDM_MODULATION,0);
    

/*
317 318 319
    for (aa=0; aa<phy_vars_eNB->frame_parms.nb_antennas_tx; aa++) {
      if (phy_vars_eNB->frame_parms.Ncp == EXTENDED) {
        PHY_ofdm_mod(&phy_vars_eNB->common_vars.txdataF[0][aa][slot_offset_F],
320
                     dummy_tx_b,
321
                     phy_vars_eNB->frame_parms.ofdm_symbol_size,
322
                     6,
323
                     phy_vars_eNB->frame_parms.nb_prefix_samples,
324
                     CYCLIC_PREFIX);
325 326 327 328 329 330 331
	if (subframe_select(&phy_vars_eNB->frame_parms,subframe) == SF_DL) 
	  PHY_ofdm_mod(&phy_vars_eNB->common_vars.txdataF[0][aa][slot_offset_F+slot_sizeF],
		       dummy_tx_b+(phy_vars_eNB->frame_parms.samples_per_tti>>1),
		       phy_vars_eNB->frame_parms.ofdm_symbol_size,
		       6,
		       phy_vars_eNB->frame_parms.nb_prefix_samples,
		       CYCLIC_PREFIX);
332
      } else {
333
        normal_prefix_mod(&phy_vars_eNB->common_vars.txdataF[0][aa][slot_offset_F],
334 335
                          dummy_tx_b,
                          7,
336
                          &(phy_vars_eNB->frame_parms));
337
	// if S-subframe generate first slot only
338
	if (subframe_select(&phy_vars_eNB->frame_parms,subframe) == SF_DL)
339 340
	  normal_prefix_mod(&phy_vars_eNB->common_vars.txdataF[0][aa][slot_offset_F+slot_sizeF],
			    dummy_tx_b+(phy_vars_eNB->frame_parms.samples_per_tti>>1),
341
			    7,
342
			    &(phy_vars_eNB->frame_parms));
343
      }
344
    } */
345

346
    for (aa=0; aa<phy_vars_eNB->frame_parms.nb_antennas_tx; aa++) {
347
      // if S-subframe generate first slot only
348 349
      if (subframe_select(&phy_vars_eNB->frame_parms,subframe) == SF_S)
	len = phy_vars_eNB->frame_parms.samples_per_tti>>1;
350
      else
351
	len = phy_vars_eNB->frame_parms.samples_per_tti;
352 353 354 355 356 357 358
      /*
      for (i=0;i<len;i+=4) {
	dummy_tx_b[i] = 0x100;
	dummy_tx_b[i+1] = 0x01000000;
	dummy_tx_b[i+2] = 0xff00;
	dummy_tx_b[i+3] = 0xff000000;
	}*/
359 360
      for (i=0; i<len; i++) {
        tx_offset = (int)slot_offset+time_offset[aa]+i;
361

362 363
	
        if (tx_offset<0)
364
          tx_offset += LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*phy_vars_eNB->frame_parms.samples_per_tti;
365

366 367
        if (tx_offset>=(LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*phy_vars_eNB->frame_parms.samples_per_tti))
          tx_offset -= LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*phy_vars_eNB->frame_parms.samples_per_tti;
368

369
/*	((short*)&phy_vars_eNB->common_vars.txdata[0][aa][tx_offset])[0] = ((short*)dummy_tx_b)[2*i]<<openair0_cfg[0].iq_txshift;
370
	
371
	((short*)&phy_vars_eNB->common_vars.txdata[0][aa][tx_offset])[1] = ((short*)dummy_tx_b)[2*i+1]<<openair0_cfg[0].iq_txshift; */
372

373
	((short*)&phy_vars_eNB->common_vars.txdata[0][aa][tx_offset])[0] = ((short*)&phy_vars_eNB->common_vars.txdata[0][aa][tx_offset])[0]<<openair0_cfg[0].iq_txshift;
374
	
375
	((short*)&phy_vars_eNB->common_vars.txdata[0][aa][tx_offset])[1] = ((short*)&phy_vars_eNB->common_vars.txdata[0][aa][tx_offset])[1]<<openair0_cfg[0].iq_txshift;
376
     }
377
     // if S-subframe switch to RX in second subframe
378
     if (subframe_select(&phy_vars_eNB->frame_parms,subframe) == SF_S) {
379
       for (i=0; i<len; i++) {
380
	 phy_vars_eNB->common_vars.txdata[0][aa][tx_offset++] = 0x00010001;
381 382
       }
     }
383

384
     if ((((phy_vars_eNB->frame_parms.tdd_config==0) ||
385 386 387
	  (phy_vars_eNB->frame_parms.tdd_config==1) ||
	  (phy_vars_eNB->frame_parms.tdd_config==2) ||
	  (phy_vars_eNB->frame_parms.tdd_config==6)) && 
388
	  (subframe==0)) || (subframe==5)) {
389 390 391
       // turn on tx switch N_TA_offset before
       //LOG_D(HW,"subframe %d, time to switch to tx (N_TA_offset %d, slot_offset %d) \n",subframe,phy_vars_eNB->N_TA_offset,slot_offset);
       for (i=0; i<phy_vars_eNB->N_TA_offset; i++) {
392
         tx_offset = (int)slot_offset+time_offset[aa]+i-phy_vars_eNB->N_TA_offset;
393 394
         if (tx_offset<0)
           tx_offset += LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*phy_vars_eNB->frame_parms.samples_per_tti;
395
	 
396 397
	 if (tx_offset>=(LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*phy_vars_eNB->frame_parms.samples_per_tti))
	   tx_offset -= LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*phy_vars_eNB->frame_parms.samples_per_tti;
398
	 
399
	 phy_vars_eNB->common_vars.txdata[0][aa][tx_offset] = 0x00000000;
400 401 402 403
       }
     }
    }
  }
404 405
}

406

407
void tx_fh_if5(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc) {
408
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, proc->timestamp_tx&0xffffffff );
409 410 411
  send_IF5(eNB, proc->timestamp_tx, proc->subframe_tx, &seqno, IF5_RRH_GW_DL);
}

412 413 414 415 416
void tx_fh_if5_mobipass(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc) {
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, proc->timestamp_tx&0xffffffff );
  send_IF5(eNB, proc->timestamp_tx, proc->subframe_tx, &seqno, IF5_MOBIPASS); 
}

417
void tx_fh_if4p5(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc) {    
418
  send_IF4p5(eNB,proc->frame_tx,proc->subframe_tx, IF4p5_PDLFFT, 0);
419 420
}

421 422 423 424
void proc_tx_high0(PHY_VARS_eNB *eNB,
		   eNB_rxtx_proc_t *proc,
		   relaying_type_t r_type,
		   PHY_VARS_RN *rn) {
425

Raymond.Knopp's avatar
Raymond.Knopp committed
426
  int offset = proc == &eNB->proc.proc_rxtx[0] ? 0 : 1;
Raymond Knopp's avatar
Raymond Knopp committed
427 428

  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_ENB+offset, proc->frame_tx );
429
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_ENB+offset, proc->subframe_tx );
Raymond Knopp's avatar
Raymond Knopp committed
430

431
  phy_procedures_eNB_TX(eNB,proc,r_type,rn,1);
432 433 434 435 436 437 438 439 440 441 442 443 444 445

  /* we're done, let the next one proceed */
  if (pthread_mutex_lock(&sync_phy_proc.mutex_phy_proc_tx) != 0) {
    LOG_E(PHY, "[SCHED][eNB] error locking PHY proc mutex for eNB TX proc\n");
    exit_fun("nothing to add");
  }	
  sync_phy_proc.phy_proc_CC_id++;
  sync_phy_proc.phy_proc_CC_id %= MAX_NUM_CCs;
  pthread_cond_broadcast(&sync_phy_proc.cond_phy_proc_tx);
  if (pthread_mutex_unlock(&sync_phy_proc.mutex_phy_proc_tx) != 0) {
    LOG_E(PHY, "[SCHED][eNB] error unlocking PHY proc mutex for eNB TX proc\n");
    exit_fun("nothing to add");
  }

446 447 448 449 450 451
}

void proc_tx_high(PHY_VARS_eNB *eNB,
		  eNB_rxtx_proc_t *proc,
		  relaying_type_t r_type,
		  PHY_VARS_RN *rn) {
452

Raymond Knopp's avatar
Raymond Knopp committed
453

454 455 456 457 458 459 460 461 462 463 464 465
  // do PHY high
  proc_tx_high0(eNB,proc,r_type,rn);

  // if TX fronthaul go ahead 
  if (eNB->tx_fh) eNB->tx_fh(eNB,proc);

}

void proc_tx_full(PHY_VARS_eNB *eNB,
		  eNB_rxtx_proc_t *proc,
		  relaying_type_t r_type,
		  PHY_VARS_RN *rn) {
466

467 468 469 470 471 472

  // do PHY high
  proc_tx_high0(eNB,proc,r_type,rn);
  // do OFDM modulation
  do_OFDM_mod_rt(proc->subframe_tx,eNB);
  // if TX fronthaul go ahead 
473 474
  if (eNB->tx_fh) eNB->tx_fh(eNB,proc);

475
  /*
476 477 478 479 480 481 482 483 484 485
  if (proc->frame_tx>1000) {
    write_output("/tmp/txsig0.m","txs0", &eNB->common_vars.txdata[eNB->Mod_id][0][0], eNB->frame_parms.samples_per_tti*10,1,1);
    write_output("/tmp/txsigF0.m","txsF0", &eNB->common_vars.txdataF[eNB->Mod_id][0][0],eNB->frame_parms.symbols_per_tti*eNB->frame_parms.ofdm_symbol_size*10,1,1);
    write_output("/tmp/txsig1.m","txs1", &eNB->common_vars.txdata[eNB->Mod_id][1][0], eNB->frame_parms.samples_per_tti*10,1,1);
    write_output("/tmp/txsigF1.m","txsF1", &eNB->common_vars.txdataF[eNB->Mod_id][1][0],eNB->frame_parms.symbols_per_tti*eNB->frame_parms.ofdm_symbol_size*10,1,1);
    if (transmission_mode == 7) 
      write_output("/tmp/txsigF5.m","txsF5", &eNB->common_vars.txdataF[eNB->Mod_id][5][0],eNB->frame_parms.symbols_per_tti*eNB->frame_parms.ofdm_symbol_size*10,1,1);
    exit_fun("");
  }
  */
486 487
}

488 489 490 491
void proc_tx_rru_if4p5(PHY_VARS_eNB *eNB,
		       eNB_rxtx_proc_t *proc,
		       relaying_type_t r_type,
		       PHY_VARS_RN *rn) {
492 493 494 495 496

  uint32_t symbol_number=0;
  uint32_t symbol_mask, symbol_mask_full;
  uint16_t packet_type;

Raymond Knopp's avatar
Raymond Knopp committed
497 498 499
  int offset = proc == &eNB->proc.proc_rxtx[0] ? 0 : 1;

  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_ENB+offset, proc->frame_tx );
500
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_ENB+offset, proc->subframe_tx );
Raymond Knopp's avatar
Raymond Knopp committed
501

502 503 504 505 506
  /// **** recv_IF4 of txdataF from RCC **** ///             
  symbol_number = 0;
  symbol_mask = 0;
  symbol_mask_full = (1<<eNB->frame_parms.symbols_per_tti)-1;
  
Raymond Knopp's avatar
Raymond Knopp committed
507

508 509 510 511 512 513 514 515 516
  do { 
    recv_IF4p5(eNB, &proc->frame_tx, &proc->subframe_tx, &packet_type, &symbol_number);
    symbol_mask = symbol_mask | (1<<symbol_number);
  } while (symbol_mask != symbol_mask_full); 

  do_OFDM_mod_rt(proc->subframe_tx, eNB);
}

void proc_tx_rru_if5(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc) {
Raymond Knopp's avatar
Raymond Knopp committed
517 518 519
  int offset = proc == &eNB->proc.proc_rxtx[0] ? 0 : 1;

  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_ENB+offset, proc->frame_tx );
520
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_ENB+offset, proc->subframe_tx );
521 522
  /// **** recv_IF5 of txdata from BBU **** ///       
  recv_IF5(eNB, &proc->timestamp_tx, proc->subframe_tx, IF5_RRH_GW_DL);
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
int wait_CCs(eNB_rxtx_proc_t *proc) {

  struct timespec wait;

  wait.tv_sec=0;
  wait.tv_nsec=5000000L;

  if (pthread_mutex_timedlock(&sync_phy_proc.mutex_phy_proc_tx,&wait) != 0) {
    LOG_E(PHY, "[SCHED][eNB] error locking PHY proc mutex for eNB TX\n");
    exit_fun("nothing to add");
    return(-1);
  }
  
  // wait for our turn or oai_exit
  while (sync_phy_proc.phy_proc_CC_id != proc->CC_id && !oai_exit) {
    pthread_cond_wait(&sync_phy_proc.cond_phy_proc_tx,
		      &sync_phy_proc.mutex_phy_proc_tx);
  }
  
  if (pthread_mutex_unlock(&sync_phy_proc.mutex_phy_proc_tx) != 0) {
    LOG_E(PHY, "[SCHED][eNB] error unlocking PHY proc mutex for eNB TX\n");
    exit_fun("nothing to add");
    return(-1);
  }
  return(0);
}
551

Raymond Knopp's avatar
Raymond Knopp committed
552 553 554
static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_name) {

  start_meas(&softmodem_stats_rxtx_sf);
555

Raymond Knopp's avatar
Raymond Knopp committed
556 557
  // ****************************************
  // Common RX procedures subframe n
558

559 560
  if ((eNB->do_prach)&&((eNB->node_function != NGFI_RCC_IF4p5)))
    eNB->do_prach(eNB,proc->frame_rx,proc->subframe_rx);
561
  phy_procedures_eNB_common_RX(eNB,proc);
Raymond Knopp's avatar
Raymond Knopp committed
562 563 564 565 566 567 568 569 570
  
  // UE-specific RX processing for subframe n
  if (eNB->proc_uespec_rx) eNB->proc_uespec_rx(eNB, proc, no_relay );
  
  // *****************************************
  // TX processing for subframe n+4
  // run PHY TX procedures the one after the other for all CCs to avoid race conditions
  // (may be relaxed in the future for performance reasons)
  // *****************************************
571
  //if (wait_CCs(proc)<0) return(-1);
Raymond Knopp's avatar
Raymond Knopp committed
572 573 574 575 576 577 578 579 580 581 582 583
  
  if (oai_exit) return(-1);
  
  if (eNB->proc_tx)	eNB->proc_tx(eNB, proc, no_relay, NULL );
  
  if (release_thread(&proc->mutex_rxtx,&proc->instance_cnt_rxtx,thread_name)<0) return(-1);

  stop_meas( &softmodem_stats_rxtx_sf );
  
  return(0);
}

584
/*!
585
 * \brief The RX UE-specific and TX thread of eNB.
586 587 588
 * \param param is a \ref eNB_proc_t structure which contains the info what to process.
 * \returns a pointer to an int. The storage is not on the heap and must not be freed.
 */
589 590
static void* eNB_thread_rxtx( void* param ) {

591
  static int eNB_thread_rxtx_status;
592

593
  eNB_rxtx_proc_t *proc = (eNB_rxtx_proc_t*)param;
594 595
  PHY_VARS_eNB *eNB = PHY_vars_eNB_g[0][proc->CC_id];

Raymond Knopp's avatar
Raymond Knopp committed
596 597
  char thread_name[100];

598

599
  // set default return value
600
  eNB_thread_rxtx_status = 0;
601 602


Raymond Knopp's avatar
Raymond Knopp committed
603
  sprintf(thread_name,"RXn_TXnp4_%d\n",&eNB->proc.proc_rxtx[0] == proc ? 0 : 1);
604
  thread_top_init(thread_name,1,850000L,1000000L,2000000L);
605 606

  while (!oai_exit) {
607
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_RXTX0+(proc->subframe_rx&1), 0 );
608

Raymond Knopp's avatar
Raymond Knopp committed
609
    if (wait_on_condition(&proc->mutex_rxtx,&proc->cond_rxtx,&proc->instance_cnt_rxtx,thread_name)<0) break;
610

611
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_RXTX0+(proc->subframe_rx&1), 1 );
612

Raymond Knopp's avatar
Raymond Knopp committed
613
    
614
  
615 616
    if (oai_exit) break;

617 618
    if (eNB->CC_id==0)
      if (rxtx(eNB,proc,thread_name) < 0) break;
619

Raymond Knopp's avatar
Raymond Knopp committed
620
  } // while !oai_exit
621

622
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_eNB_PROC_RXTX0+(proc->subframe_rx&1), 0 );
623

Raymond Knopp's avatar
Raymond Knopp committed
624
  printf( "Exiting eNB thread RXn_TXnp4\n");
625

626 627
  eNB_thread_rxtx_status = 0;
  return &eNB_thread_rxtx_status;
628 629
}

630
#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
631 632 633
/* Wait for eNB application initialization to be complete (eNB registration to MME) */
static void wait_system_ready (char *message, volatile int *start_flag) {
  
634
  static char *indicator[] = {".    ", "..   ", "...  ", ".... ", ".....",
635
			      " ....", "  ...", "   ..", "    .", "     "};
636 637 638 639 640 641 642
  int i = 0;
  
  while ((!oai_exit) && (*start_flag == 0)) {
    LOG_N(EMU, message, indicator[i]);
    fflush(stdout);
    i = (i + 1) % (sizeof(indicator) / sizeof(indicator[0]));
    usleep(200000);
643
  }
644 645
  
  LOG_D(EMU,"\n");
646 647
}
#endif
648

Raymond Knopp's avatar
Raymond Knopp committed
649

650
// asynchronous UL with IF5 (RCC,RAU,eNodeB_BBU)
Raymond Knopp's avatar
Raymond Knopp committed
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
void fh_if5_asynch_UL(PHY_VARS_eNB *eNB,int *frame,int *subframe) {

  eNB_proc_t *proc       = &eNB->proc;
  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;

  recv_IF5(eNB, &proc->timestamp_rx, *subframe, IF5_RRH_GW_UL); 

  proc->subframe_rx = (proc->timestamp_rx/fp->samples_per_tti)%10;
  proc->frame_rx    = (proc->timestamp_rx/(10*fp->samples_per_tti))&1023;

  if (proc->first_rx != 0) {
    proc->first_rx = 0;
    *subframe = proc->subframe_rx;
    *frame    = proc->frame_rx; 
  }
  else {
    if (proc->subframe_rx != *subframe) {
668
      LOG_E(PHY,"fh_if5_asynch_UL: subframe_rx %d is not what we expect %d\n",proc->subframe_rx,*subframe);
Raymond Knopp's avatar
Raymond Knopp committed
669 670 671
      exit_fun("Exiting");
    }
    if (proc->frame_rx != *frame) {
672
      LOG_E(PHY,"fh_if5_asynch_UL: subframe_rx %d is not what we expect %d\n",proc->frame_rx,*frame);  
Raymond Knopp's avatar
Raymond Knopp committed
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
      exit_fun("Exiting");
    }
  }
} // eNodeB_3GPP_BBU 

// asynchronous UL with IF4p5 (RCC,RAU,eNodeB_BBU)
void fh_if4p5_asynch_UL(PHY_VARS_eNB *eNB,int *frame,int *subframe) {

  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
  eNB_proc_t *proc       = &eNB->proc;

  uint16_t packet_type;
  uint32_t symbol_number,symbol_mask,symbol_mask_full,prach_rx;


  symbol_number = 0;
  symbol_mask = 0;
  symbol_mask_full = (1<<fp->symbols_per_tti)-1;
  prach_rx = 0;

  do {   // Blocking, we need a timeout on this !!!!!!!!!!!!!!!!!!!!!!!
    recv_IF4p5(eNB, &proc->frame_rx, &proc->subframe_rx, &packet_type, &symbol_number);
    if (proc->first_rx != 0) {
      *frame = proc->frame_rx;
      *subframe = proc->subframe_rx;
      proc->first_rx = 0;
    }
    else {
      if (proc->frame_rx != *frame) {
702
	LOG_E(PHY,"fh_if4p5_asynch_UL: frame_rx %d is not what we expect %d\n",proc->frame_rx,*frame);
Raymond Knopp's avatar
Raymond Knopp committed
703 704 705
	exit_fun("Exiting");
      }
      if (proc->subframe_rx != *subframe) {
706
	LOG_E(PHY,"fh_if4p5_asynch_UL: subframe_rx %d is not what we expect %d\n",proc->subframe_rx,*subframe);
Raymond Knopp's avatar
Raymond Knopp committed
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
	exit_fun("Exiting");
      }
    }
    if (packet_type == IF4p5_PULFFT) {
      symbol_mask = symbol_mask | (1<<symbol_number);
      prach_rx = (is_prach_subframe(fp, proc->frame_rx, proc->subframe_rx)>0) ? 1 : 0;                            
    } else if (packet_type == IF4p5_PRACH) {
      prach_rx = 0;
    }
  } while( (symbol_mask != symbol_mask_full) || (prach_rx == 1));    
  

} 


void fh_if5_asynch_DL(PHY_VARS_eNB *eNB,int *frame,int *subframe) {

  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
  eNB_proc_t *proc       = &eNB->proc;
  int subframe_tx,frame_tx;
  openair0_timestamp timestamp_tx;

  recv_IF5(eNB, &timestamp_tx, *subframe, IF5_RRH_GW_DL); 
Raymond Knopp's avatar
Raymond Knopp committed
730
  //printf("Received subframe %d (TS %llu) from RCC\n",subframe_tx,timestamp_tx);
Raymond Knopp's avatar
Raymond Knopp committed
731 732 733 734

  subframe_tx = (timestamp_tx/fp->samples_per_tti)%10;
  frame_tx    = (timestamp_tx/(fp->samples_per_tti*10))&1023;

735 736 737
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_ENB, frame_tx );
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_ENB, subframe_tx );

Raymond Knopp's avatar
Raymond Knopp committed
738 739 740 741 742 743 744
  if (proc->first_tx != 0) {
    *subframe = subframe_tx;
    *frame    = frame_tx;
    proc->first_tx = 0;
  }
  else {
    if (subframe_tx != *subframe) {
745
      LOG_E(PHY,"fh_if5_asynch_DL: subframe_tx %d is not what we expect %d\n",subframe_tx,*subframe);
Raymond Knopp's avatar
Raymond Knopp committed
746 747 748
      exit_fun("Exiting");
    }
    if (frame_tx != *frame) { 
749
      LOG_E(PHY,"fh_if5_asynch_DL: frame_tx %d is not what we expect %d\n",frame_tx,*frame);
Raymond Knopp's avatar
Raymond Knopp committed
750 751 752 753 754 755 756 757 758 759 760
      exit_fun("Exiting");
    }
  }
}

void fh_if4p5_asynch_DL(PHY_VARS_eNB *eNB,int *frame,int *subframe) {

  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
  eNB_proc_t *proc       = &eNB->proc;

  uint16_t packet_type;
761
  uint32_t symbol_number,symbol_mask_full;
Raymond Knopp's avatar
Raymond Knopp committed
762 763 764 765 766 767 768 769 770 771 772
  int subframe_tx,frame_tx;

  symbol_number = 0;
  symbol_mask_full = (1<<fp->symbols_per_tti)-1;

  do {   // Blocking, we need a timeout on this !!!!!!!!!!!!!!!!!!!!!!!
    recv_IF4p5(eNB, &frame_tx, &subframe_tx, &packet_type, &symbol_number);
    if (proc->first_tx != 0) {
      *frame    = frame_tx;
      *subframe = subframe_tx;
      proc->first_tx = 0;
773
      proc->frame_offset = frame_tx - proc->frame_tx;
Raymond Knopp's avatar
Raymond Knopp committed
774 775 776
    }
    else {
      if (frame_tx != *frame) {
777
	LOG_E(PHY,"fh_if4p5_asynch_DL: frame_tx %d is not what we expect %d\n",frame_tx,*frame);
778
	exit_fun("Exiting");
Raymond Knopp's avatar
Raymond Knopp committed
779 780
      }
      if (subframe_tx != *subframe) {
781 782
	LOG_E(PHY,"fh_if4p5_asynch_DL: (frame %d) subframe_tx %d is not what we expect %d\n",frame_tx,subframe_tx,*subframe);
	//*subframe = subframe_tx;
783
	exit_fun("Exiting");
Raymond Knopp's avatar
Raymond Knopp committed
784 785 786
      }
    }
    if (packet_type == IF4p5_PDLFFT) {
787
      proc->symbol_mask[subframe_tx] =proc->symbol_mask[subframe_tx] | (1<<symbol_number);
Raymond Knopp's avatar
Raymond Knopp committed
788 789 790 791 792
    }
    else {
      LOG_E(PHY,"Illegal IF4p5 packet type (should only be IF4p5_PDLFFT%d\n",packet_type);
      exit_fun("Exiting");
    }
793 794
  } while (proc->symbol_mask[*subframe] != symbol_mask_full);    

795 796
  *frame = frame_tx;

797

798 799 800
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_TX0_ENB, frame_tx );
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_TX0_ENB, subframe_tx );

801 802
  // intialize this to zero after we're done with the subframe
  proc->symbol_mask[*subframe] = 0;
Raymond Knopp's avatar
Raymond Knopp committed
803
  
804
  do_OFDM_mod_rt(*subframe, eNB);
Raymond Knopp's avatar
Raymond Knopp committed
805 806
} 

807
/*!
808
 * \brief The Asynchronous RX/TX FH thread of RAU/RCC/eNB/RRU.
809 810 811 812
 * This handles the RX FH for an asynchronous RRU/UE
 * \param param is a \ref eNB_proc_t structure which contains the info what to process.
 * \returns a pointer to an int. The storage is not on the heap and must not be freed.
 */
813
static void* eNB_thread_asynch_rxtx( void* param ) {
814

815
  static int eNB_thread_asynch_rxtx_status;
816

817 818
  eNB_proc_t *proc = (eNB_proc_t*)param;
  PHY_VARS_eNB *eNB = PHY_vars_eNB_g[0][proc->CC_id];
Raymond Knopp's avatar
Raymond Knopp committed
819 820


821

Raymond Knopp's avatar
Raymond Knopp committed
822
  int subframe=0, frame=0; 
823

824
  thread_top_init("thread_asynch",1,870000L,1000000L,1000000L);
825 826 827

  // wait for top-level synchronization and do one acquisition to get timestamp for setting frame/subframe

Raymond Knopp's avatar
Raymond Knopp committed
828
  wait_sync("thread_asynch");
829

830 831
  // wait for top-level synchronization and do one acquisition to get timestamp for setting frame/subframe
  printf( "waiting for devices (eNB_thread_asynch_rx)\n");
832

Raymond Knopp's avatar
Raymond Knopp committed
833
  wait_on_condition(&proc->mutex_asynch_rxtx,&proc->cond_asynch_rxtx,&proc->instance_cnt_asynch_rxtx,"thread_asynch");
834

835 836 837
  printf( "devices ok (eNB_thread_asynch_rx)\n");


Raymond Knopp's avatar
Raymond Knopp committed
838 839 840
  while (!oai_exit) { 
   
    if (oai_exit) break;   
841

Raymond Knopp's avatar
Raymond Knopp committed
842 843 844 845 846 847 848
    if (subframe==9) { 
      subframe=0;
      frame++;
      frame&=1023;
    } else {
      subframe++;
    }      
849

Raymond Knopp's avatar
Raymond Knopp committed
850 851 852
    if (eNB->fh_asynch) eNB->fh_asynch(eNB,&frame,&subframe);
    else AssertFatal(1==0, "Unknown eNB->node_function %d",eNB->node_function);
    
853
  }
854

855 856
  eNB_thread_asynch_rxtx_status=0;
  return(&eNB_thread_asynch_rxtx_status);
857
}
858

859

Raymond Knopp's avatar
Raymond Knopp committed
860 861 862 863 864 865



void rx_rf(PHY_VARS_eNB *eNB,int *frame,int *subframe) {

  eNB_proc_t *proc = &eNB->proc;
866 867 868 869
  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
  void *rxp[fp->nb_antennas_rx],*txp[fp->nb_antennas_tx]; 
  unsigned int rxs,txs;
  int i;
870
  int tx_sfoffset = (eNB->single_thread_flag == 1) ? 3 : 2;
871
  openair0_timestamp ts,old_ts;
872

873 874
  if (proc->first_rx==0) {
    
875
    // Transmit TX buffer based on timestamp from RX
876
    //    printf("trx_write -> USRP TS %llu (sf %d)\n", (proc->timestamp_rx+(3*fp->samples_per_tti)),(proc->subframe_rx+2)%10);
877
    VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, (proc->timestamp_rx+(tx_sfoffset*fp->samples_per_tti)-openair0_cfg[0].tx_sample_advance)&0xffffffff );
878 879
    // prepare tx buffer pointers
	
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
    if ((subframe_select(fp,proc->subframe_rx+tx_sfoffset) == SF_DL) ||
	(subframe_select(fp,proc->subframe_rx+tx_sfoffset) == SF_S)) {
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 1 );

      for (i=0; i<fp->nb_antennas_tx; i++)
	txp[i] = (void*)&eNB->common_vars.txdata[0][i][((proc->subframe_rx+tx_sfoffset)%10)*fp->samples_per_tti]; 
      
      txs = eNB->rfdevice.trx_write_func(&eNB->rfdevice,
					 proc->timestamp_rx+eNB->ts_offset+(tx_sfoffset*fp->samples_per_tti)-openair0_cfg[0].tx_sample_advance,
					 txp,
					 fp->samples_per_tti,
					 fp->nb_antennas_tx,
					 1);
      
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, 0 );
      
      
      
      if (txs !=  fp->samples_per_tti) {
	LOG_E(PHY,"TX : Timeout (sent %d/%d)\n",txs, fp->samples_per_tti);
	exit_fun( "problem transmitting samples" );
      }	
    }
903
  }
904

905 906 907 908
  for (i=0; i<fp->nb_antennas_rx; i++)
    rxp[i] = (void*)&eNB->common_vars.rxdata[0][i][*subframe*fp->samples_per_tti];
  
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 1 );
909

910 911
  old_ts = proc->timestamp_rx;

912
  rxs = eNB->rfdevice.trx_read_func(&eNB->rfdevice,
913
				    &ts,
914 915 916
				    rxp,
				    fp->samples_per_tti,
				    fp->nb_antennas_rx);
917

918 919
  proc->timestamp_rx = ts-eNB->ts_offset;

920
  if (rxs != fp->samples_per_tti)
921
    LOG_E(PHY,"rx_rf: Asked for %d samples, got %d from USRP\n",fp->samples_per_tti,rxs);
922

923
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, 0 );
Raymond Knopp's avatar
Raymond Knopp committed
924
 
925
  if (proc->first_rx == 1) {
Raymond Knopp's avatar
Raymond Knopp committed
926
    eNB->ts_offset = proc->timestamp_rx;
927 928
    proc->timestamp_rx=0;
  }
929
  else {
930

931
    if (proc->timestamp_rx - old_ts != fp->samples_per_tti) {
932 933
      LOG_I(PHY,"rx_rf: rfdevice timing drift of %d samples\n",proc->timestamp_rx - old_ts - fp->samples_per_tti);
      eNB->ts_offset += (proc->timestamp_rx - old_ts - fp->samples_per_tti);
934
      proc->timestamp_rx = ts-eNB->ts_offset;
935 936
    }
  }
937 938
  proc->frame_rx    = (proc->timestamp_rx / (fp->samples_per_tti*10))&1023;
  proc->subframe_rx = (proc->timestamp_rx / fp->samples_per_tti)%10;
939
  proc->frame_rx    = (proc->frame_rx+proc->frame_offset)&1023;
940
  proc->frame_tx    = proc->frame_rx;
941
  if (proc->subframe_rx > 5) proc->frame_tx=(proc->frame_tx+1)&1023;
942 943
  // synchronize first reception to frame 0 subframe 0

944
  proc->timestamp_tx = proc->timestamp_rx+(4*fp->samples_per_tti);
945
  //  printf("trx_read <- USRP TS %lu (offset %d sf %d, f %d, first_rx %d)\n", proc->timestamp_rx,eNB->ts_offset,proc->subframe_rx,proc->frame_rx,proc->first_rx);  
946 947 948
  
  if (proc->first_rx == 0) {
    if (proc->subframe_rx != *subframe){
949
      LOG_E(PHY,"rx_rf: Received Timestamp (%llu) doesn't correspond to the time we think it is (proc->subframe_rx %d, subframe %d)\n",proc->timestamp_rx,proc->subframe_rx,*subframe);
950 951
      exit_fun("Exiting");
    }
952
    int f2 = (*frame+proc->frame_offset)&1023;    
953
    if (proc->frame_rx != f2) {
954
      LOG_E(PHY,"rx_rf: Received Timestamp (%llu) doesn't correspond to the time we think it is (proc->frame_rx %d frame %d, frame_offset %d, f2 %d)\n",proc->timestamp_rx,proc->frame_rx,*frame,proc->frame_offset,f2);
955 956 957 958 959 960 961 962 963 964 965 966
      exit_fun("Exiting");
    }
  } else {
    proc->first_rx = 0;
    *frame = proc->frame_rx;
    *subframe = proc->subframe_rx;        
  }
  
  //printf("timestamp_rx %lu, frame %d(%d), subframe %d(%d)\n",proc->timestamp_rx,proc->frame_rx,frame,proc->subframe_rx,subframe);
  
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS, proc->timestamp_rx&0xffffffff );
  
967 968 969 970 971
  if (rxs != fp->samples_per_tti)
    exit_fun( "problem receiving samples" );
  

  
972 973
}

Raymond Knopp's avatar
Raymond Knopp committed
974
void rx_fh_if5(PHY_VARS_eNB *eNB,int *frame, int *subframe) {
975 976

  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
Raymond Knopp's avatar
Raymond Knopp committed
977
  eNB_proc_t *proc = &eNB->proc;
978 979 980

  recv_IF5(eNB, &proc->timestamp_rx, *subframe, IF5_RRH_GW_UL); 

981 982
  proc->frame_rx    = (proc->timestamp_rx / (fp->samples_per_tti*10))&1023;
  proc->subframe_rx = (proc->timestamp_rx / fp->samples_per_tti)%10;
983 984
  
  if (proc->first_rx == 0) {
985
    if (proc->subframe_rx != *subframe){
986
      LOG_E(PHY,"rx_fh_if5: Received Timestamp doesn't correspond to the time we think it is (proc->subframe_rx %d, subframe %d)\n",proc->subframe_rx,subframe);
987 988 989
      exit_fun("Exiting");
    }
    
990
    if (proc->frame_rx != *frame) {
991
      LOG_E(PHY,"rx_fh_if5: Received Timestamp doesn't correspond to the time we think it is (proc->frame_rx %d frame %d)\n",proc->frame_rx,frame);
992 993 994 995
      exit_fun("Exiting");
    }
  } else {
    proc->first_rx = 0;
996 997
    *frame = proc->frame_rx;
    *subframe = proc->subframe_rx;        
998
  }      
Raymond.Knopp's avatar
Raymond.Knopp committed
999

1000 1001


Raymond.Knopp's avatar
Raymond.Knopp committed
1002
  proc->timestamp_tx = proc->timestamp_rx +  (4*fp->samples_per_tti);
1003 1004 1005 1006 1007
  
  VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS, proc->timestamp_rx&0xffffffff );

}

Raymond Knopp's avatar
Raymond Knopp committed
1008

1009
void rx_fh_if4p5(PHY_VARS_eNB *eNB,int *frame,int *subframe) {
1010 1011

  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
1012
  eNB_proc_t *proc = &eNB->proc;
1013
  int f,sf;
1014 1015 1016 1017 1018 1019

  uint16_t packet_type;
  uint32_t symbol_number=0;
  uint32_t symbol_mask, symbol_mask_full;

  symbol_mask_full = (1<<fp->symbols_per_tti)-1;
1020

1021
  if (eNB->CC_id==1) LOG_I(PHY,"rx_fh_if4p5: frame %d, subframe %d\n",*frame,*subframe);
1022
  do {   // Blocking, we need a timeout on this !!!!!!!!!!!!!!!!!!!!!!!
1023
    recv_IF4p5(eNB, &f, &sf, &packet_type, &symbol_number);
1024

1025
    //proc->frame_rx = (proc->frame_rx + proc->frame_offset)&1023;
1026
    if (packet_type == IF4p5_PULFFT) {
1027
      LOG_D(PHY,"rx_fh:if4p5: frame %d, subframe %d, PULFFT symbol %d\n",f,sf,symbol_number);
1028

Raymond.Knopp's avatar
Raymond.Knopp committed
1029
      proc->symbol_mask[sf] = proc->symbol_mask[sf] | (1<<symbol_number);
1030
    } else if (packet_type == IF4p5_PRACH) {
1031
      LOG_D(PHY,"rx_fh:if4p5: frame %d, subframe %d, PRACH\n",f,sf);
1032 1033
      // wakeup prach processing
      if (eNB->do_prach) eNB->do_prach(eNB,f,sf);
1034
    }
1035

1036
    if (eNB->CC_id==1) LOG_I(PHY,"rx_fh_if4p5: symbol_mask[%d] %x\n",*subframe,proc->symbol_mask[*subframe]);
1037

1038
  } while(proc->symbol_mask[*subframe] != symbol_mask_full);    
Raymond.Knopp's avatar
Raymond.Knopp committed
1039 1040 1041
  proc->subframe_rx = *subframe;
  proc->frame_rx = *frame;

1042 1043 1044 1045
  proc->symbol_mask[*subframe] = 0;
  proc->symbol_mask[(9+*subframe)%10]= 0; // to handle a resynchronization event

  if (eNB->CC_id==1) LOG_I(PHY,"Clearing symbol_mask[%d]\n",*subframe);
1046 1047

  //caculate timestamp_rx, timestamp_tx based on frame and subframe
1048 1049 1050
  proc->timestamp_rx = ((proc->frame_rx * 10)  + proc->subframe_rx ) * fp->samples_per_tti ;
  proc->timestamp_tx = proc->timestamp_rx +  (4*fp->samples_per_tti);
  
1051
 
1052 1053
  if (proc->first_rx == 0) {
    if (proc->subframe_rx != *subframe){
1054
      LOG_E(PHY,"rx_fh_if4p5, CC_id %d: Received Timestamp doesn't correspond to the time we think it is (proc->subframe_rx %d, subframe %d,CCid %d)\n",eNB->CC_id,proc->subframe_rx,*subframe,eNB->CC_id);
1055 1056
    }
    if (proc->frame_rx != *frame) {
1057 1058 1059 1060
      if (proc->frame_rx == proc->frame_offset) // This means that the RRU has adjusted its frame timing
	proc->frame_offset = 0;
      else 
	LOG_E(PHY,"rx_fh_if4p5: Received Timestamp doesn't correspond to the time we think it is (proc->frame_rx %d frame %d,CCid %d)\n",proc->frame_rx,*frame,eNB->CC_id);
1061 1062 1063
    }
  } else {
    proc->first_rx = 0;
1064 1065 1066 1067 1068
    if (eNB->CC_id==0)
      proc->frame_offset = 0;
    else
      proc->frame_offset = PHY_vars_eNB_g[0][0]->proc.frame_rx;

1069
    *frame = proc->frame_rx;//(proc->frame_rx + proc->frame_offset)&1023;
1070 1071 1072
    *subframe = proc->subframe_rx;        
  }
  
1073 1074 1075


  if (eNB->CC_id==0) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS, proc->timestamp_rx&0xffffffff );
1076 1077 1078
  
}

Raymond Knopp's avatar
Raymond Knopp committed
1079 1080
void rx_fh_slave(PHY_VARS_eNB *eNB,int *frame,int *subframe) {
  // This case is for synchronization to another thread
1081
  // it just waits for an external event.  The actual rx_fh is handle by the asynchronous RX thread
Raymond Knopp's avatar
Raymond Knopp committed
1082 1083
  eNB_proc_t *proc=&eNB->proc;

Raymond Knopp's avatar
Raymond Knopp committed
1084 1085 1086 1087 1088
  if (wait_on_condition(&proc->mutex_FH,&proc->cond_FH,&proc->instance_cnt_FH,"rx_fh_slave") < 0)
    return;

  release_thread(&proc->mutex_FH,&proc->instance_cnt_FH,"rx_fh_slave");

Raymond Knopp's avatar
Raymond Knopp committed
1089 1090 1091 1092
  
}


1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124
int wakeup_rxtx(eNB_proc_t *proc,eNB_rxtx_proc_t *proc_rxtx,LTE_DL_FRAME_PARMS *fp) {

  int i;
  struct timespec wait;
  
  wait.tv_sec=0;
  wait.tv_nsec=5000000L;

  /* accept some delay in processing - up to 5ms */
  for (i = 0; i < 10 && proc_rxtx->instance_cnt_rxtx == 0; i++) {
    LOG_W( PHY,"[eNB] Frame %d, eNB RXn-TXnp4 thread busy!! (cnt_rxtx %i)\n", proc_rxtx->frame_tx, proc_rxtx->instance_cnt_rxtx);
    usleep(500);
  }
  if (proc_rxtx->instance_cnt_rxtx == 0) {
    exit_fun( "TX thread busy" );
    return(-1);
  }

  // wake up TX for subframe n+4
  // lock the TX mutex and make sure the thread is ready
  if (pthread_mutex_timedlock(&proc_rxtx->mutex_rxtx,&wait) != 0) {
    LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB RXTX thread %d (IC %d)\n", proc_rxtx->subframe_rx&1,proc_rxtx->instance_cnt_rxtx );
    exit_fun( "error locking mutex_rxtx" );
    return(-1);
  }
  
  ++proc_rxtx->instance_cnt_rxtx;
  
  // We have just received and processed the common part of a subframe, say n. 
  // TS_rx is the last received timestamp (start of 1st slot), TS_tx is the desired 
  // transmitted timestamp of the next TX slot (first).
  // The last (TS_rx mod samples_per_frame) was n*samples_per_tti, 
Raymond Knopp's avatar
Raymond Knopp committed
1125 1126
  // we want to generate subframe (n+4), so TS_tx = TX_rx+4*samples_per_tti,
  // and proc->subframe_tx = proc->subframe_rx+4
1127 1128 1129 1130 1131 1132 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 1159 1160 1161 1162 1163 1164 1165 1166
  proc_rxtx->timestamp_tx = proc->timestamp_rx + (4*fp->samples_per_tti);
  proc_rxtx->frame_rx     = proc->frame_rx;
  proc_rxtx->subframe_rx  = proc->subframe_rx;
  proc_rxtx->frame_tx     = (proc_rxtx->subframe_rx > 5) ? (proc_rxtx->frame_rx+1)&1023 : proc_rxtx->frame_rx;
  proc_rxtx->subframe_tx  = (proc_rxtx->subframe_rx + 4)%10;
  
  // the thread can now be woken up
  if (pthread_cond_signal(&proc_rxtx->cond_rxtx) != 0) {
    LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB RXn-TXnp4 thread\n");
    exit_fun( "ERROR pthread_cond_signal" );
    return(-1);
  }
  
  pthread_mutex_unlock( &proc_rxtx->mutex_rxtx );

  return(0);
}

void wakeup_slaves(eNB_proc_t *proc) {

  int i;
  struct timespec wait;
  
  wait.tv_sec=0;
  wait.tv_nsec=5000000L;
  
  for (i=0;i<proc->num_slaves;i++) {
    eNB_proc_t *slave_proc = proc->slave_proc[i];
    // wake up slave FH thread
    // lock the FH mutex and make sure the thread is ready
    if (pthread_mutex_timedlock(&slave_proc->mutex_FH,&wait) != 0) {
      LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB CCid %d slave CCid %d (IC %d)\n",proc->CC_id,slave_proc->CC_id);
      exit_fun( "error locking mutex_rxtx" );
      break;
    }
    
    int cnt_slave            = ++slave_proc->instance_cnt_FH;
    slave_proc->frame_rx     = proc->frame_rx;
    slave_proc->subframe_rx  = proc->subframe_rx;
    slave_proc->timestamp_rx = proc->timestamp_rx;
1167 1168
    slave_proc->timestamp_tx = proc->timestamp_tx; 

1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
    pthread_mutex_unlock( &slave_proc->mutex_FH );
    
    if (cnt_slave == 0) {
      // the thread was presumably waiting where it should and can now be woken up
      if (pthread_cond_signal(&slave_proc->cond_FH) != 0) {
	LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB CCid %d, slave CCid %d\n",proc->CC_id,slave_proc->CC_id);
          exit_fun( "ERROR pthread_cond_signal" );
	  break;
      }
    } else {
1179
      LOG_W( PHY,"[eNB] Frame %d, slave CC_id %d thread busy!! (cnt_FH %i)\n",slave_proc->frame_rx,slave_proc->CC_id, cnt_slave);
1180 1181 1182 1183 1184 1185
      exit_fun( "FH thread busy" );
      break;
    }             
  }
}

1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
uint32_t sync_corr[307200] __attribute__((aligned(32)));

// This thread run the initial synchronization like a UE
void *eNB_thread_synch(void *arg) {

  PHY_VARS_eNB *eNB = (PHY_VARS_eNB*)arg;
  LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
  int32_t sync_pos,sync_pos2;
  uint32_t peak_val;

  thread_top_init("eNB_thread_synch",0,5000000,10000000,10000000);

  wait_sync("eNB_thread_synch");

  // initialize variables for PSS detection
  lte_sync_time_init(&eNB->frame_parms);

  while (!oai_exit) {

    // wait to be woken up
    pthread_mutex_lock(&eNB->proc.mutex_synch);
    while (eNB->proc.instance_cnt_synch < 0)
      pthread_cond_wait(&eNB->proc.cond_synch,&eNB->proc.mutex_synch);
    pthread_mutex_unlock(&eNB->proc.mutex_synch);

    // if we're not in synch, then run initial synch
    if (eNB->in_synch == 0) { 
      // run intial synch like UE
      LOG_I(PHY,"Running initial synchronization\n");
      
      sync_pos = lte_sync_time_eNB(eNB->common_vars.rxdata[0],
				   fp,
				   fp->samples_per_tti*5,
				   &peak_val,
				   sync_corr);
      LOG_I(PHY,"eNB synch: %d, val %d\n",sync_pos,peak_val);

      if (sync_pos >= 0) {
	if (sync_pos >= fp->nb_prefix_samples)
	  sync_pos2 = sync_pos - fp->nb_prefix_samples;
	else
	  sync_pos2 = sync_pos + (fp->samples_per_tti*10) - fp->nb_prefix_samples;
	
	if (fp->frame_type == FDD) {
	  
	  // PSS is hypothesized in last symbol of first slot in Frame
	  int sync_pos_slot = (fp->samples_per_tti>>1) - fp->ofdm_symbol_size - fp->nb_prefix_samples;
	  
	  if (sync_pos2 >= sync_pos_slot)
	    eNB->rx_offset = sync_pos2 - sync_pos_slot;
	  else
	    eNB->rx_offset = (fp->samples_per_tti*10) + sync_pos2 - sync_pos_slot;
	}
	else {
	  
	}

	LOG_I(PHY,"Estimated sync_pos %d, peak_val %d => timing offset %d\n",sync_pos,peak_val,eNB->rx_offset);
	
1245 1246
	/*
	if ((peak_val > 300000) && (sync_pos > 0)) {
1247 1248 1249 1250
	//      if (sync_pos++ > 3) {
	write_output("eNB_sync.m","sync",(void*)&sync_corr[0],fp->samples_per_tti*5,1,2);
	write_output("eNB_rx.m","rxs",(void*)eNB->common_vars.rxdata[0][0],fp->samples_per_tti*10,1,1);
	exit(-1);
1251 1252 1253
	}
	*/
	eNB->in_synch=1;
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
      }
    }

    // release thread
    pthread_mutex_lock(&eNB->proc.mutex_synch);
    eNB->proc.instance_cnt_synch--;
    pthread_mutex_unlock(&eNB->proc.mutex_synch);
  } // oai_exit

  lte_sync_time_free();

}

int wakeup_synch(PHY_VARS_eNB *eNB){

  struct timespec wait;
  
  wait.tv_sec=0;
  wait.tv_nsec=5000000L;

  // wake up synch thread
  // lock the synch mutex and make sure the thread is ready
  if (pthread_mutex_timedlock(&eNB->proc.mutex_synch,&wait) != 0) {
    LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB synch thread (IC %d)\n", eNB->proc.instance_cnt_synch );
    exit_fun( "error locking mutex_synch" );
    return(-1);
  }
  
  ++eNB->proc.instance_cnt_synch;
  
  // the thread can now be woken up
  if (pthread_cond_signal(&eNB->proc.cond_synch) != 0) {
    LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB synch thread\n");
    exit_fun( "ERROR pthread_cond_signal" );
    return(-1);
  }
  
  pthread_mutex_unlock( &eNB->proc.mutex_synch );

  return(0);
}

1296
/*!
1297 1298 1299
 * \brief The Fronthaul thread of RRU/RAU/RCC/eNB
 * In the case of RRU/eNB, handles interface with external RF
 * In the case of RAU/RCC, handles fronthaul interface with RRU/RAU
1300 1301 1302
 * \param param is a \ref eNB_proc_t structure which contains the info what to process.
 * \returns a pointer to an int. The storage is not on the heap and must not be freed.
 */
Raymond Knopp's avatar
Raymond Knopp committed
1303

1304
static void* eNB_thread_FH( void* param ) {
1305
  
1306
  static int eNB_thread_FH_status;
1307 1308

  eNB_proc_t *proc = (eNB_proc_t*)param;
1309 1310
  PHY_VARS_eNB *eNB = PHY_vars_eNB_g[0][proc->CC_id];
  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
1311

Sandeep Kumar's avatar
Sandeep Kumar committed
1312
  int subframe=0, frame=0; 
1313

1314
  // set default return value
1315
  eNB_thread_FH_status = 0;
1316

1317
  thread_top_init("eNB_thread_FH",0,870000,1000000,1000000);
1318

Raymond Knopp's avatar
Raymond Knopp committed
1319
  wait_sync("eNB_thread_FH");
1320

1321
#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
Raymond Knopp's avatar
Raymond Knopp committed
1322 1323
  if (eNB->node_function < NGFI_RRU_IF5)
    wait_system_ready ("Waiting for eNB application to be ready %s\r", &start_eNB);
1324
#endif 
1325

1326 1327 1328
  // Start IF device if any
  if (eNB->start_if) 
    if (eNB->start_if(eNB) != 0)
1329
      LOG_E(HW,"Could not start the IF device\n");
1330

Raymond Knopp's avatar
Raymond Knopp committed
1331 1332 1333 1334 1335
  // Start RF device if any
  if (eNB->start_rf)
    if (eNB->start_rf(eNB) != 0)
      LOG_E(HW,"Could not start the RF device\n");

Raymond Knopp's avatar
Raymond Knopp committed
1336
  // wakeup asnych_rxtx thread because the devices are ready at this point
1337 1338 1339 1340 1341
  pthread_mutex_lock(&proc->mutex_asynch_rxtx);
  proc->instance_cnt_asynch_rxtx=0;
  pthread_mutex_unlock(&proc->mutex_asynch_rxtx);
  pthread_cond_signal(&proc->cond_asynch_rxtx);

1342 1343
  // This is a forever while loop, it loops over subframes which are scheduled by incoming samples from HW devices
  while (!oai_exit) {
1344

Raymond Knopp's avatar
Raymond Knopp committed
1345 1346
    // these are local subframe/frame counters to check that we are in synch with the fronthaul timing.
    // They are set on the first rx/tx in the underly FH routines.
1347 1348 1349 1350 1351 1352 1353 1354
    if (subframe==9) { 
      subframe=0;
      frame++;
      frame&=1023;
    } else {
      subframe++;
    }      

Raymond Knopp's avatar
Raymond Knopp committed
1355 1356 1357 1358
 
    // synchronization on FH interface, acquire signals/data and block
    if (eNB->rx_fh) eNB->rx_fh(eNB,&frame,&subframe);
    else AssertFatal(1==0, "No fronthaul interface : eNB->node_function %d",eNB->node_function);
1359

Cedric Roux's avatar
Cedric Roux committed
1360 1361
    T(T_ENB_MASTER_TICK, T_INT(0), T_INT(proc->frame_rx), T_INT(proc->subframe_rx));

1362 1363
    // At this point, all information for subframe has been received on FH interface
    // If this proc is to provide synchronization, do so
1364
    wakeup_slaves(proc);
1365 1366
      
    // wake up RXn_TXnp4 thread for the subframe
1367
    // choose even or odd thread for RXn-TXnp4 processing 
1368
    if (wakeup_rxtx(proc,&proc->proc_rxtx[proc->subframe_rx&1],fp) < 0)
1369
      break;
1370

Raymond Knopp's avatar
Raymond Knopp committed
1371
    // artifical sleep for very slow fronthaul
1372 1373
    if (eNB->frame_parms.N_RB_DL==6)
      rt_sleep_ns(800000LL);
1374 1375 1376
  }
    
  printf( "Exiting FH thread \n");
Raymond Knopp's avatar
Raymond Knopp committed
1377
 
1378 1379
  eNB_thread_FH_status = 0;
  return &eNB_thread_FH_status;
1380 1381 1382 1383 1384 1385 1386 1387
}


/*!
 * \brief The prach receive thread of eNB.
 * \param param is a \ref eNB_proc_t structure which contains the info what to process.
 * \returns a pointer to an int. The storage is not on the heap and must not be freed.
 */
1388
static void* eNB_thread_prach( void* param ) {
1389 1390 1391 1392
  static int eNB_thread_prach_status;

  eNB_proc_t *proc = (eNB_proc_t*)param;
  PHY_VARS_eNB *eNB= PHY_vars_eNB_g[0][proc->CC_id];
Raymond Knopp's avatar
Raymond Knopp committed
1393

1394 1395 1396
  // set default return value
  eNB_thread_prach_status = 0;

1397
  thread_top_init("eNB_thread_prach",1,500000L,1000000L,20000000L);
1398

1399 1400 1401 1402
  while (!oai_exit) {
    
    if (oai_exit) break;

Raymond Knopp's avatar
Raymond Knopp committed
1403
    if (wait_on_condition(&proc->mutex_prach,&proc->cond_prach,&proc->instance_cnt_prach,"eNB_prach_thread") < 0) break;
Raymond Knopp's avatar
Raymond Knopp committed
1404
    
1405
    prach_procedures(eNB);
1406
    
Raymond Knopp's avatar
Raymond Knopp committed
1407
    if (release_thread(&proc->mutex_prach,&proc->instance_cnt_prach,"eNB_prach_thread") < 0) break;
1408
  }
1409

1410
  printf( "Exiting eNB thread PRACH\n");
Raymond Knopp's avatar
Raymond Knopp committed
1411

1412 1413
  eNB_thread_prach_status = 0;
  return &eNB_thread_prach_status;
1414 1415
}

1416 1417


Raymond Knopp's avatar
Raymond Knopp committed
1418 1419 1420 1421 1422 1423 1424
static void* eNB_thread_single( void* param ) {

  static int eNB_thread_single_status;

  eNB_proc_t *proc = (eNB_proc_t*)param;
  eNB_rxtx_proc_t *proc_rxtx = &proc->proc_rxtx[0];
  PHY_VARS_eNB *eNB = PHY_vars_eNB_g[0][proc->CC_id];
1425 1426 1427
  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;

  void *rxp[2],*rxp2[2];
Raymond Knopp's avatar
Raymond Knopp committed
1428 1429 1430

  int subframe=0, frame=0; 

1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
  int32_t dummy_rx[fp->nb_antennas_rx][fp->samples_per_tti] __attribute__((aligned(32)));

  int ic;

  int rxs;

  int i;

  // initialize the synchronization buffer to the common_vars.rxdata
  for (int i=0;i<fp->nb_antennas_rx;i++)
    rxp[i] = &eNB->common_vars.rxdata[0][i][0];

Raymond Knopp's avatar
Raymond Knopp committed
1443 1444 1445
  // set default return value
  eNB_thread_single_status = 0;

1446
  thread_top_init("eNB_thread_single",0,870000,1000000,1000000);
Raymond Knopp's avatar
Raymond Knopp committed
1447 1448 1449

  wait_sync("eNB_thread_single");

1450
#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
Raymond Knopp's avatar
Raymond Knopp committed
1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
  if (eNB->node_function < NGFI_RRU_IF5)
    wait_system_ready ("Waiting for eNB application to be ready %s\r", &start_eNB);
#endif 

  // Start IF device if any
  if (eNB->start_if) 
    if (eNB->start_if(eNB) != 0)
      LOG_E(HW,"Could not start the IF device\n");

  // Start RF device if any
  if (eNB->start_rf)
    if (eNB->start_rf(eNB) != 0)
      LOG_E(HW,"Could not start the RF device\n");

  // wakeup asnych_rxtx thread because the devices are ready at this point
  pthread_mutex_lock(&proc->mutex_asynch_rxtx);
  proc->instance_cnt_asynch_rxtx=0;
  pthread_mutex_unlock(&proc->mutex_asynch_rxtx);
  pthread_cond_signal(&proc->cond_asynch_rxtx);

1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513


  // if this is a slave eNB, try to synchronize on the DL frequency
  if ((eNB->is_slave) &&
      ((eNB->node_function >= NGFI_RRU_IF5))) {
    // if FDD, switch RX on DL frequency
    
    double temp_freq1 = eNB->rfdevice.openair0_cfg->rx_freq[0];
    double temp_freq2 = eNB->rfdevice.openair0_cfg->tx_freq[0];
    for (i=0;i<4;i++) {
      eNB->rfdevice.openair0_cfg->rx_freq[i] = eNB->rfdevice.openair0_cfg->tx_freq[i];
      eNB->rfdevice.openair0_cfg->tx_freq[i] = temp_freq1;
    }
    eNB->rfdevice.trx_set_freq_func(&eNB->rfdevice,eNB->rfdevice.openair0_cfg,0);

    while ((eNB->in_synch ==0)&&(!oai_exit)) {
      // read in frame
      rxs = eNB->rfdevice.trx_read_func(&eNB->rfdevice,
					&(proc->timestamp_rx),
					rxp,
					fp->samples_per_tti*10,
					fp->nb_antennas_rx);
      // wakeup synchronization processing thread
      wakeup_synch(eNB);
      ic=0;
      
      while ((ic>=0)&&(!oai_exit)) {
	// continuously read in frames, 1ms at a time, 
	// until we are done with the synchronization procedure
	
	for (i=0; i<fp->nb_antennas_rx; i++)
	  rxp2[i] = (void*)&dummy_rx[i][0];
	for (i=0;i<10;i++)
	  rxs = eNB->rfdevice.trx_read_func(&eNB->rfdevice,
					    &(proc->timestamp_rx),
					    rxp2,
					    fp->samples_per_tti,
					    fp->nb_antennas_rx);
	pthread_mutex_lock(&eNB->proc.mutex_synch);
	ic = eNB->proc.instance_cnt_synch;
	pthread_mutex_unlock(&eNB->proc.mutex_synch);
      } // ic>=0
    } // in_synch==0
1514 1515 1516 1517 1518 1519 1520
    // read in rx_offset samples
    LOG_I(PHY,"Resynchronizing by %d samples\n",eNB->rx_offset);
    rxs = eNB->rfdevice.trx_read_func(&eNB->rfdevice,
				      &(proc->timestamp_rx),
				      rxp,
				      eNB->rx_offset,
				      fp->nb_antennas_rx);
1521 1522
    for (i=0;i<4;i++) {
      eNB->rfdevice.openair0_cfg->rx_freq[i] = temp_freq1;
1523
      eNB->rfdevice.openair0_cfg->tx_freq[i] = temp_freq2;
1524
    }
1525
    eNB->rfdevice.trx_set_freq_func(&eNB->rfdevice,eNB->rfdevice.openair0_cfg,1);
1526 1527 1528
  } // if RRU and slave


Raymond Knopp's avatar
Raymond Knopp committed
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
  // This is a forever while loop, it loops over subframes which are scheduled by incoming samples from HW devices
  while (!oai_exit) {

    // these are local subframe/frame counters to check that we are in synch with the fronthaul timing.
    // They are set on the first rx/tx in the underly FH routines.
    if (subframe==9) { 
      subframe=0;
      frame++;
      frame&=1023;
    } else {
      subframe++;
    }      

Raymond.Knopp's avatar
Raymond.Knopp committed
1542 1543
    if (eNB->CC_id==1) 
	LOG_I(PHY,"eNB thread single %p (proc %p, CC_id %d), frame %d (%p), subframe %d (%p)\n",
luhan wang's avatar
luhan wang committed
1544
	  pthread_self(), proc, eNB->CC_id, frame,&frame,subframe,&subframe);
Raymond Knopp's avatar
Raymond Knopp committed
1545 1546 1547 1548 1549 1550 1551
 
    // synchronization on FH interface, acquire signals/data and block
    if (eNB->rx_fh) eNB->rx_fh(eNB,&frame,&subframe);
    else AssertFatal(1==0, "No fronthaul interface : eNB->node_function %d",eNB->node_function);

    T(T_ENB_MASTER_TICK, T_INT(0), T_INT(proc->frame_rx), T_INT(proc->subframe_rx));

1552 1553 1554
    proc_rxtx->subframe_rx = proc->subframe_rx;
    proc_rxtx->frame_rx    = proc->frame_rx;
    proc_rxtx->subframe_tx = (proc->subframe_rx+4)%10;
1555 1556
    proc_rxtx->frame_tx    = (proc->subframe_rx>5) ? (1+proc->frame_rx)&1023 : proc->frame_rx;
    proc->frame_tx         = proc_rxtx->frame_tx;
1557
    proc_rxtx->timestamp_tx = proc->timestamp_tx;
1558 1559
    // adjust for timing offset between RRU
    if (eNB->CC_id!=0) proc_rxtx->frame_tx = (proc_rxtx->frame_tx+proc->frame_offset)&1023;
1560

Raymond Knopp's avatar
Raymond Knopp committed
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
    // At this point, all information for subframe has been received on FH interface
    // If this proc is to provide synchronization, do so
    wakeup_slaves(proc);

    if (rxtx(eNB,proc_rxtx,"eNB_thread_single") < 0) break;
  }
  

  printf( "Exiting eNB_single thread \n");
 
  eNB_thread_single_status = 0;
  return &eNB_thread_single_status;

}

1576
extern void init_fep_thread(PHY_VARS_eNB *, pthread_attr_t *);
1577 1578
extern void init_td_thread(PHY_VARS_eNB *, pthread_attr_t *);
extern void init_te_thread(PHY_VARS_eNB *, pthread_attr_t *);
1579

1580
void init_eNB_proc(int inst) {
1581
  
Rohit Gupta's avatar
Rohit Gupta committed
1582
  int i=0;
1583
  int CC_id;
1584 1585
  PHY_VARS_eNB *eNB;
  eNB_proc_t *proc;
1586
  eNB_rxtx_proc_t *proc_rxtx;
1587
  pthread_attr_t *attr0=NULL,*attr1=NULL,*attr_FH=NULL,*attr_prach=NULL,*attr_asynch=NULL,*attr_single=NULL,*attr_fep=NULL,*attr_td=NULL,*attr_te=NULL,*attr_synch=NULL;
Raymond Knopp's avatar
Raymond Knopp committed
1588

1589 1590
  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
    eNB = PHY_vars_eNB_g[inst][CC_id];
laurent's avatar
laurent committed
1591
#ifndef OCP_FRAMEWORK
1592
    LOG_I(PHY,"Initializing eNB %d CC_id %d (%s,%s),\n",inst,CC_id,eNB_functions[eNB->node_function],eNB_timing[eNB->node_timing]);
laurent's avatar
laurent committed
1593
#endif
1594
    proc = &eNB->proc;
Raymond Knopp's avatar
Raymond Knopp committed
1595

1596 1597 1598
    proc_rxtx = proc->proc_rxtx;
    proc_rxtx[0].instance_cnt_rxtx = -1;
    proc_rxtx[1].instance_cnt_rxtx = -1;
1599 1600
    proc->instance_cnt_prach       = -1;
    proc->instance_cnt_FH          = -1;
1601
    proc->instance_cnt_asynch_rxtx = -1;
1602
    proc->CC_id = CC_id;    
1603 1604
    proc->instance_cnt_synch        =  -1;

Raymond Knopp's avatar
Raymond Knopp committed
1605 1606
    proc->first_rx=1;
    proc->first_tx=1;
1607
    proc->frame_offset = 0;
Raymond Knopp's avatar
Raymond Knopp committed
1608

1609 1610
    for (i=0;i<10;i++) proc->symbol_mask[i]=0;

1611 1612 1613 1614
    pthread_mutex_init( &proc_rxtx[0].mutex_rxtx, NULL);
    pthread_mutex_init( &proc_rxtx[1].mutex_rxtx, NULL);
    pthread_cond_init( &proc_rxtx[0].cond_rxtx, NULL);
    pthread_cond_init( &proc_rxtx[1].cond_rxtx, NULL);
Raymond Knopp's avatar
Raymond Knopp committed
1615 1616 1617

    pthread_mutex_init( &proc->mutex_prach, NULL);
    pthread_mutex_init( &proc->mutex_asynch_rxtx, NULL);
1618
    pthread_mutex_init( &proc->mutex_synch,NULL);
Raymond Knopp's avatar
Raymond Knopp committed
1619

1620 1621
    pthread_cond_init( &proc->cond_prach, NULL);
    pthread_cond_init( &proc->cond_FH, NULL);
1622
    pthread_cond_init( &proc->cond_asynch_rxtx, NULL);
1623
    pthread_cond_init( &proc->cond_synch,NULL);
1624 1625 1626

    pthread_attr_init( &proc->attr_FH);
    pthread_attr_init( &proc->attr_prach);
1627
    pthread_attr_init( &proc->attr_synch);
1628 1629 1630
    pthread_attr_init( &proc->attr_asynch_rxtx);
    pthread_attr_init( &proc->attr_single);
    pthread_attr_init( &proc->attr_fep);
1631 1632
    pthread_attr_init( &proc->attr_td);
    pthread_attr_init( &proc->attr_te);
1633 1634
    pthread_attr_init( &proc_rxtx[0].attr_rxtx);
    pthread_attr_init( &proc_rxtx[1].attr_rxtx);
1635
#ifndef DEADLINE_SCHEDULER
Raymond Knopp's avatar
Raymond Knopp committed
1636 1637 1638 1639
    attr0       = &proc_rxtx[0].attr_rxtx;
    attr1       = &proc_rxtx[1].attr_rxtx;
    attr_FH     = &proc->attr_FH;
    attr_prach  = &proc->attr_prach;
1640
    attr_synch  = &proc->attr_synch;
Raymond Knopp's avatar
Raymond Knopp committed
1641 1642
    attr_asynch = &proc->attr_asynch_rxtx;
    attr_single = &proc->attr_single;
1643
    attr_fep    = &proc->attr_fep;
1644 1645
    attr_td     = &proc->attr_td;
    attr_te     = &proc->attr_te; 
Raymond Knopp's avatar
Raymond Knopp committed
1646 1647 1648 1649 1650 1651 1652
#endif

    if (eNB->single_thread_flag==0) {
      pthread_create( &proc_rxtx[0].pthread_rxtx, attr0, eNB_thread_rxtx, &proc_rxtx[0] );
      pthread_create( &proc_rxtx[1].pthread_rxtx, attr1, eNB_thread_rxtx, &proc_rxtx[1] );
      pthread_create( &proc->pthread_FH, attr_FH, eNB_thread_FH, &eNB->proc );
    }
1653
    else {
Raymond Knopp's avatar
Raymond Knopp committed
1654
      pthread_create(&proc->pthread_single, attr_single, eNB_thread_single, &eNB->proc);
1655
      init_fep_thread(eNB,attr_fep);
1656 1657
      init_td_thread(eNB,attr_td);
      init_te_thread(eNB,attr_te);
1658
    }
Raymond Knopp's avatar
Raymond Knopp committed
1659
    pthread_create( &proc->pthread_prach, attr_prach, eNB_thread_prach, &eNB->proc );
1660
    pthread_create( &proc->pthread_synch, attr_synch, eNB_thread_synch, eNB);
1661
    if ((eNB->node_timing == synch_to_other) ||
Raymond Knopp's avatar
Raymond Knopp committed
1662 1663
	(eNB->node_function == NGFI_RRU_IF5) ||
	(eNB->node_function == NGFI_RRU_IF4p5))
1664 1665


Raymond Knopp's avatar
Raymond Knopp committed
1666 1667
      pthread_create( &proc->pthread_asynch_rxtx, attr_asynch, eNB_thread_asynch_rxtx, &eNB->proc );

1668
    char name[16];
1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
    if (eNB->single_thread_flag == 0) {
      snprintf( name, sizeof(name), "RXTX0 %d", i );
      pthread_setname_np( proc_rxtx[0].pthread_rxtx, name );
      snprintf( name, sizeof(name), "RXTX1 %d", i );
      pthread_setname_np( proc_rxtx[1].pthread_rxtx, name );
      snprintf( name, sizeof(name), "FH %d", i );
      pthread_setname_np( proc->pthread_FH, name );
    }
    else {
      snprintf( name, sizeof(name), " %d", i );
      pthread_setname_np( proc->pthread_single, name );
    }
1681
  }
1682

1683
  //for multiple CCs: setup master and slaves
luhan wang's avatar
luhan wang committed
1684
  /*
1685
  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
1686 1687
    eNB = PHY_vars_eNB_g[inst][CC_id];

1688
    if (eNB->node_timing == synch_to_ext_device) { //master
1689 1690 1691 1692
      eNB->proc.num_slaves = MAX_NUM_CCs-1;
      eNB->proc.slave_proc = (eNB_proc_t**)malloc(eNB->proc.num_slaves*sizeof(eNB_proc_t*));

      for (i=0; i< eNB->proc.num_slaves; i++) {
1693 1694
        if (i < CC_id)  eNB->proc.slave_proc[i] = &(PHY_vars_eNB_g[inst][i]->proc);
        if (i >= CC_id)  eNB->proc.slave_proc[i] = &(PHY_vars_eNB_g[inst][i+1]->proc);
1695 1696
      }
    }
luhan wang's avatar
luhan wang committed
1697
    }*/
1698 1699


1700 1701 1702 1703
  /* setup PHY proc TX sync mechanism */
  pthread_mutex_init(&sync_phy_proc.mutex_phy_proc_tx, NULL);
  pthread_cond_init(&sync_phy_proc.cond_phy_proc_tx, NULL);
  sync_phy_proc.phy_proc_CC_id = 0;
1704 1705
}

1706

1707

1708 1709 1710
/*!
 * \brief Terminate eNB TX and RX threads.
 */
1711
void kill_eNB_proc(int inst) {
1712

1713
  int *status;
1714 1715
  PHY_VARS_eNB *eNB;
  eNB_proc_t *proc;
1716
  eNB_rxtx_proc_t *proc_rxtx;
1717
  for (int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
1718
    eNB=PHY_vars_eNB_g[inst][CC_id];
1719 1720
    
    proc = &eNB->proc;
1721
    proc_rxtx = &proc->proc_rxtx[0];
1722
    
1723
#ifdef DEBUG_THREADS
1724
    printf( "Killing TX CC_id %d thread %d\n", CC_id, i );
1725
#endif
1726
    
1727 1728
    proc_rxtx[0].instance_cnt_rxtx = 0; // FIXME data race!
    proc_rxtx[1].instance_cnt_rxtx = 0; // FIXME data race!
Raymond Knopp's avatar
Raymond Knopp committed
1729
    proc->instance_cnt_prach = 0;
1730
    proc->instance_cnt_FH = 0;
1731
    pthread_cond_signal( &proc_rxtx[0].cond_rxtx );    
Raymond Knopp's avatar
Raymond Knopp committed
1732 1733
    pthread_cond_signal( &proc_rxtx[1].cond_rxtx );
    pthread_cond_signal( &proc->cond_prach );
1734
    pthread_cond_signal( &proc->cond_FH );
1735
    pthread_cond_broadcast(&sync_phy_proc.cond_phy_proc_tx);
Raymond Knopp's avatar
Raymond Knopp committed
1736

1737 1738 1739 1740 1741 1742 1743
    pthread_join( proc->pthread_FH, (void**)&status ); 
    pthread_mutex_destroy( &proc->mutex_FH );
    pthread_cond_destroy( &proc->cond_FH );
            
    pthread_join( proc->pthread_prach, (void**)&status );    
    pthread_mutex_destroy( &proc->mutex_prach );
    pthread_cond_destroy( &proc->cond_prach );         
1744

1745
    int i;
Raymond Knopp's avatar
Raymond Knopp committed
1746
    for (i=0;i<2;i++) {
1747 1748 1749 1750
      pthread_join( proc_rxtx[i].pthread_rxtx, (void**)&status );
      pthread_mutex_destroy( &proc_rxtx[i].mutex_rxtx );
      pthread_cond_destroy( &proc_rxtx[i].cond_rxtx );
    }
1751
  }
1752 1753
}

1754

1755 1756 1757 1758
/* this function maps the phy_vars_eNB tx and rx buffers to the available rf chains.
   Each rf chain is is addressed by the card number and the chain on the card. The
   rf_map specifies for each CC, on which rf chain the mapping should start. Multiple
   antennas are mapped to successive RF chains on the same card. */
1759
int setup_eNB_buffers(PHY_VARS_eNB **phy_vars_eNB, openair0_config_t *openair0_cfg) {
1760

1761 1762
  int i,j; 
  int CC_id,card,ant;
1763

1764
  //uint16_t N_TA_offset = 0;
1765

1766 1767 1768 1769
  LTE_DL_FRAME_PARMS *frame_parms;

  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
    if (phy_vars_eNB[CC_id]) {
1770
      frame_parms = &(phy_vars_eNB[CC_id]->frame_parms);
1771 1772 1773 1774 1775 1776
      printf("setup_eNB_buffers: frame_parms = %p\n",frame_parms);
    } else {
      printf("phy_vars_eNB[%d] not initialized\n", CC_id);
      return(-1);
    }

1777
    /*
1778 1779 1780 1781 1782 1783 1784 1785
    if (frame_parms->frame_type == TDD) {
      if (frame_parms->N_RB_DL == 100)
        N_TA_offset = 624;
      else if (frame_parms->N_RB_DL == 50)
        N_TA_offset = 624/2;
      else if (frame_parms->N_RB_DL == 25)
        N_TA_offset = 624/4;
    }
1786
    */
Raymond Knopp's avatar
Raymond Knopp committed
1787
 
1788

Raymond Knopp's avatar
Raymond Knopp committed
1789
    if (openair0_cfg[CC_id].mmapped_dma == 1) {
1790
    // replace RX signal buffers with mmaped HW versions
Raymond Knopp's avatar
Raymond Knopp committed
1791 1792
      
      for (i=0; i<frame_parms->nb_antennas_rx; i++) {
1793 1794 1795
	card = i/4;
	ant = i%4;
	printf("Mapping eNB CC_id %d, rx_ant %d, on card %d, chain %d\n",CC_id,i,phy_vars_eNB[CC_id]->rf_map.card+card, phy_vars_eNB[CC_id]->rf_map.chain+ant);
Raymond Knopp's avatar
Raymond Knopp committed
1796
	free(phy_vars_eNB[CC_id]->common_vars.rxdata[0][i]);
1797
	phy_vars_eNB[CC_id]->common_vars.rxdata[0][i] = openair0_cfg[phy_vars_eNB[CC_id]->rf_map.card+card].rxbase[phy_vars_eNB[CC_id]->rf_map.chain+ant];
Raymond Knopp's avatar
Raymond Knopp committed
1798 1799 1800 1801 1802 1803
	
	printf("rxdata[%d] @ %p\n",i,phy_vars_eNB[CC_id]->common_vars.rxdata[0][i]);
	for (j=0; j<16; j++) {
	  printf("rxbuffer %d: %x\n",j,phy_vars_eNB[CC_id]->common_vars.rxdata[0][i][j]);
	  phy_vars_eNB[CC_id]->common_vars.rxdata[0][i][j] = 16-j;
	}
1804
      }
Raymond Knopp's avatar
Raymond Knopp committed
1805 1806
      
      for (i=0; i<frame_parms->nb_antennas_tx; i++) {
1807 1808 1809
	card = i/4;
	ant = i%4;
	printf("Mapping eNB CC_id %d, tx_ant %d, on card %d, chain %d\n",CC_id,i,phy_vars_eNB[CC_id]->rf_map.card+card, phy_vars_eNB[CC_id]->rf_map.chain+ant);
Raymond Knopp's avatar
Raymond Knopp committed
1810
	free(phy_vars_eNB[CC_id]->common_vars.txdata[0][i]);
1811
	phy_vars_eNB[CC_id]->common_vars.txdata[0][i] = openair0_cfg[phy_vars_eNB[CC_id]->rf_map.card+card].txbase[phy_vars_eNB[CC_id]->rf_map.chain+ant];
Raymond Knopp's avatar
Raymond Knopp committed
1812 1813 1814 1815 1816 1817 1818
	
	printf("txdata[%d] @ %p\n",i,phy_vars_eNB[CC_id]->common_vars.txdata[0][i]);
	
	for (j=0; j<16; j++) {
	  printf("txbuffer %d: %x\n",j,phy_vars_eNB[CC_id]->common_vars.txdata[0][i][j]);
	  phy_vars_eNB[CC_id]->common_vars.txdata[0][i][j] = 16-j;
	}
1819 1820
      }
    }
Raymond Knopp's avatar
Raymond Knopp committed
1821
    else {  // not memory-mapped DMA 
1822 1823
      //nothing to do, everything already allocated in lte_init
      /*
Raymond Knopp's avatar
Raymond Knopp committed
1824 1825 1826 1827 1828
      rxdata = (int32_t**)malloc16(frame_parms->nb_antennas_rx*sizeof(int32_t*));
      txdata = (int32_t**)malloc16(frame_parms->nb_antennas_tx*sizeof(int32_t*));
      
      for (i=0; i<frame_parms->nb_antennas_rx; i++) {
	free(phy_vars_eNB[CC_id]->common_vars.rxdata[0][i]);
1829
	rxdata[i] = (int32_t*)(32 + malloc16(32+frame_parms->samples_per_tti*10*sizeof(int32_t))); // FIXME broken memory allocation
1830
	phy_vars_eNB[CC_id]->common_vars.rxdata[0][i] = rxdata[i]; //-N_TA_offset; // N_TA offset for TDD         FIXME! N_TA_offset > 16 => access of unallocated memory
1831
	memset(rxdata[i], 0, frame_parms->samples_per_tti*10*sizeof(int32_t));
Raymond Knopp's avatar
Raymond Knopp committed
1832
	printf("rxdata[%d] @ %p (%p) (N_TA_OFFSET %d)\n", i, phy_vars_eNB[CC_id]->common_vars.rxdata[0][i],rxdata[i],N_TA_offset);      
1833 1834
      }
      
Raymond Knopp's avatar
Raymond Knopp committed
1835 1836
      for (i=0; i<frame_parms->nb_antennas_tx; i++) {
	free(phy_vars_eNB[CC_id]->common_vars.txdata[0][i]);
1837
	txdata[i] = (int32_t*)(32 + malloc16(32 + frame_parms->samples_per_tti*10*sizeof(int32_t))); // FIXME broken memory allocation
Raymond Knopp's avatar
Raymond Knopp committed
1838
	phy_vars_eNB[CC_id]->common_vars.txdata[0][i] = txdata[i];
1839
	memset(txdata[i],0, frame_parms->samples_per_tti*10*sizeof(int32_t));
Raymond Knopp's avatar
Raymond Knopp committed
1840
	printf("txdata[%d] @ %p\n", i, phy_vars_eNB[CC_id]->common_vars.txdata[0][i]);
1841
      }
1842
      */
1843 1844 1845 1846 1847 1848 1849 1850
    }
  }

  return(0);
}


void reset_opp_meas(void) {
1851

1852 1853 1854 1855 1856
  int sfn;
  reset_meas(&softmodem_stats_mt);
  reset_meas(&softmodem_stats_hw);
  
  for (sfn=0; sfn < 10; sfn++) {
1857
    reset_meas(&softmodem_stats_rxtx_sf);
1858
    reset_meas(&softmodem_stats_rx_sf);
1859 1860 1861
  }
}

1862

1863 1864 1865 1866 1867 1868 1869
void print_opp_meas(void) {

  int sfn=0;
  print_meas(&softmodem_stats_mt, "Main ENB Thread", NULL, NULL);
  print_meas(&softmodem_stats_hw, "HW Acquisation", NULL, NULL);
  
  for (sfn=0; sfn < 10; sfn++) {
1870
    print_meas(&softmodem_stats_rxtx_sf,"[eNB][total_phy_proc_rxtx]",NULL, NULL);
1871
    print_meas(&softmodem_stats_rx_sf,"[eNB][total_phy_proc_rx]",NULL,NULL);
1872 1873
  }
}
1874
 
1875 1876 1877 1878 1879 1880 1881
int start_if(PHY_VARS_eNB *eNB) {
  return(eNB->ifdevice.trx_start_func(&eNB->ifdevice));
}

int start_rf(PHY_VARS_eNB *eNB) {
  return(eNB->rfdevice.trx_start_func(&eNB->rfdevice));
}
1882

Raymond Knopp's avatar
Raymond Knopp committed
1883
extern void eNB_fep_rru_if5(PHY_VARS_eNB *eNB);
1884 1885
extern void eNB_fep_full(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc);
extern void eNB_fep_full_2thread(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc);
1886
extern void do_prach(PHY_VARS_eNB *eNB,int frame,int subframe);
1887

1888
void init_eNB(eNB_func_t node_function[], eNB_timing_t node_timing[],int nb_inst,eth_params_t *eth_params,int single_thread_flag,int wait_for_sync) {
1889
  
1890
  int CC_id;
1891
  int inst;
1892
  PHY_VARS_eNB *eNB;
Raymond Knopp's avatar
Raymond Knopp committed
1893 1894
  int ret;

1895 1896
  for (inst=0;inst<nb_inst;inst++) {
    for (CC_id=0;CC_id<MAX_NUM_CCs;CC_id++) {
1897 1898 1899 1900
      eNB = PHY_vars_eNB_g[inst][CC_id]; 
      eNB->node_function      = node_function[CC_id];
      eNB->node_timing        = node_timing[CC_id];
      eNB->abstraction_flag   = 0;
Raymond Knopp's avatar
Raymond Knopp committed
1901
      eNB->single_thread_flag = single_thread_flag;
Raymond Knopp's avatar
Raymond Knopp committed
1902
      eNB->ts_offset          = 0;
1903 1904 1905
      eNB->in_synch           = 0;
      eNB->is_slave           = (wait_for_sync>0) ? 1 : 0;

1906

laurent's avatar
laurent committed
1907
#ifndef OCP_FRAMEWORK
1908
      LOG_I(PHY,"Initializing eNB %d CC_id %d : (%s,%s)\n",inst,CC_id,eNB_functions[node_function[CC_id]],eNB_timing[node_timing[CC_id]]);
laurent's avatar
laurent committed
1909
#endif
Raymond Knopp's avatar
Raymond Knopp committed
1910

1911 1912
      switch (node_function[CC_id]) {
      case NGFI_RRU_IF5:
Raymond Knopp's avatar
Raymond Knopp committed
1913
	eNB->do_prach             = NULL;
1914
	eNB->do_precoding         = 0;
Raymond Knopp's avatar
Raymond Knopp committed
1915
	eNB->fep                  = eNB_fep_rru_if5;
1916 1917
	eNB->td                   = NULL;
	eNB->te                   = NULL;
Raymond Knopp's avatar
Raymond Knopp committed
1918
	eNB->proc_uespec_rx       = NULL;
1919
	eNB->proc_tx              = NULL;
Raymond Knopp's avatar
Raymond Knopp committed
1920 1921 1922 1923
	eNB->tx_fh                = NULL;
	eNB->rx_fh                = rx_rf;
	eNB->start_rf             = start_rf;
	eNB->start_if             = start_if;
Raymond Knopp's avatar
Raymond Knopp committed
1924
	eNB->fh_asynch            = fh_if5_asynch_DL;
1925
	ret = openair0_device_load(&eNB->rfdevice, &openair0_cfg[CC_id]);
Raymond Knopp's avatar
Raymond Knopp committed
1926 1927 1928 1929 1930 1931
        if (ret<0) {
          printf("Exiting, cannot initialize rf device\n");
          exit(-1);
        }
	eNB->rfdevice.host_type   = RRH_HOST;
	eNB->ifdevice.host_type   = RRH_HOST;
1932
        ret = openair0_transport_load(&eNB->ifdevice, &openair0_cfg[CC_id], (eth_params+CC_id));
Raymond Knopp's avatar
Raymond Knopp committed
1933 1934 1935 1936 1937
	printf("openair0_transport_init returns %d for CC_id %d\n",ret,CC_id);
        if (ret<0) {
          printf("Exiting, cannot initialize transport protocol\n");
          exit(-1);
        }
1938 1939
	break;
      case NGFI_RRU_IF4p5:
1940
	eNB->do_precoding         = 0;
Raymond Knopp's avatar
Raymond Knopp committed
1941
	eNB->do_prach             = do_prach;
hutch's avatar
hutch committed
1942
	eNB->fep                  = eNB_fep_full;//(single_thread_flag==1) ? eNB_fep_full_2thread : eNB_fep_full;
1943 1944
	eNB->td                   = NULL;
	eNB->te                   = NULL;
Raymond Knopp's avatar
Raymond Knopp committed
1945
	eNB->proc_uespec_rx       = NULL;
Raymond Knopp's avatar
Raymond Knopp committed
1946
	eNB->proc_tx              = NULL;//proc_tx_rru_if4p5;
Raymond Knopp's avatar
Raymond Knopp committed
1947 1948
	eNB->tx_fh                = NULL;
	eNB->rx_fh                = rx_rf;
Raymond Knopp's avatar
Raymond Knopp committed
1949
	eNB->fh_asynch            = fh_if4p5_asynch_DL;
Raymond Knopp's avatar
Raymond Knopp committed
1950 1951
	eNB->start_rf             = start_rf;
	eNB->start_if             = start_if;
1952
	ret = openair0_device_load(&eNB->rfdevice, &openair0_cfg[CC_id]);
Raymond Knopp's avatar
Raymond Knopp committed
1953 1954 1955 1956 1957 1958
        if (ret<0) {
          printf("Exiting, cannot initialize rf device\n");
          exit(-1);
        }
	eNB->rfdevice.host_type   = RRH_HOST;
	eNB->ifdevice.host_type   = RRH_HOST;
1959
	printf("loading transport interface ...\n");
1960
        ret = openair0_transport_load(&eNB->ifdevice, &openair0_cfg[CC_id], (eth_params+CC_id));
Raymond Knopp's avatar
Raymond Knopp committed
1961 1962 1963 1964 1965 1966
	printf("openair0_transport_init returns %d for CC_id %d\n",ret,CC_id);
        if (ret<0) {
          printf("Exiting, cannot initialize transport protocol\n");
          exit(-1);
        }

1967
	malloc_IF4p5_buffer(eNB);
Raymond Knopp's avatar
Raymond Knopp committed
1968

1969 1970
	break;
      case eNodeB_3GPP:
1971
	eNB->do_precoding         = 1;
Raymond Knopp's avatar
Raymond Knopp committed
1972
	eNB->do_prach             = do_prach;
hutch's avatar
hutch committed
1973
	eNB->fep                  = eNB_fep_full;//(single_thread_flag==1) ? eNB_fep_full_2thread : eNB_fep_full;
1974 1975
	eNB->td                   = ulsch_decoding_data;//(single_thread_flag==1) ? ulsch_decoding_data_2thread : ulsch_decoding_data;
	eNB->te                   = dlsch_encoding;//(single_thread_flag==1) ? dlsch_encoding_2threads : dlsch_encoding;
Raymond Knopp's avatar
Raymond Knopp committed
1976 1977 1978 1979 1980 1981
	eNB->proc_uespec_rx       = phy_procedures_eNB_uespec_RX;
	eNB->proc_tx              = proc_tx_full;
	eNB->tx_fh                = NULL;
	eNB->rx_fh                = rx_rf;
	eNB->start_rf             = start_rf;
	eNB->start_if             = NULL;
Raymond Knopp's avatar
Raymond Knopp committed
1982
        eNB->fh_asynch            = NULL;
1983
	ret = openair0_device_load(&eNB->rfdevice, &openair0_cfg[CC_id]);
Raymond Knopp's avatar
Raymond Knopp committed
1984 1985 1986 1987 1988 1989
        if (ret<0) {
          printf("Exiting, cannot initialize rf device\n");
          exit(-1);
        }
	eNB->rfdevice.host_type   = BBU_HOST;
	eNB->ifdevice.host_type   = BBU_HOST;
1990 1991
	break;
      case eNodeB_3GPP_BBU:
1992
	eNB->do_precoding   = 1;
1993
	eNB->do_prach       = do_prach;
hutch's avatar
hutch committed
1994 1995 1996
	eNB->fep            = eNB_fep_full;//(single_thread_flag==1) ? eNB_fep_full_2thread : eNB_fep_full;
	eNB->td             = ulsch_decoding_data;//(single_thread_flag==1) ? ulsch_decoding_data_2thread : ulsch_decoding_data;
	eNB->te             = dlsch_encoding;//(single_thread_flag==1) ? dlsch_encoding_2threads : dlsch_encoding;
1997 1998
	eNB->proc_uespec_rx = phy_procedures_eNB_uespec_RX;
	eNB->proc_tx        = proc_tx_full;
1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
        if (eNB->node_timing == synch_to_other) {
           eNB->tx_fh          = tx_fh_if5_mobipass;
           eNB->rx_fh          = rx_fh_slave;
           eNB->fh_asynch      = fh_if5_asynch_UL;

        }
        else {
           eNB->tx_fh          = tx_fh_if5;
           eNB->rx_fh          = rx_fh_if5;
           eNB->fh_asynch      = NULL;
        }
Raymond Knopp's avatar
Raymond Knopp committed
2010

2011 2012
	eNB->start_rf       = NULL;
	eNB->start_if       = start_if;
Raymond Knopp's avatar
Raymond Knopp committed
2013 2014 2015
	eNB->rfdevice.host_type   = BBU_HOST;

	eNB->ifdevice.host_type   = BBU_HOST;
Raymond Knopp's avatar
Raymond Knopp committed
2016

2017
        ret = openair0_transport_load(&eNB->ifdevice, &openair0_cfg[CC_id], (eth_params+CC_id));
Raymond Knopp's avatar
Raymond Knopp committed
2018 2019 2020 2021 2022
        printf("openair0_transport_init returns %d for CC_id %d\n",ret,CC_id);
        if (ret<0) {
          printf("Exiting, cannot initialize transport protocol\n");
          exit(-1);
        }
2023 2024
	break;
      case NGFI_RCC_IF4p5:
2025
	eNB->do_precoding         = 0;
Raymond Knopp's avatar
Raymond Knopp committed
2026 2027
	eNB->do_prach             = do_prach;
	eNB->fep                  = NULL;
hutch's avatar
hutch committed
2028 2029
	eNB->td                   = ulsch_decoding_data;//(single_thread_flag==1) ? ulsch_decoding_data_2thread : ulsch_decoding_data;
	eNB->te                   = dlsch_encoding;//(single_thread_flag==1) ? dlsch_encoding_2threads : dlsch_encoding;
Raymond Knopp's avatar
Raymond Knopp committed
2030 2031 2032 2033 2034 2035 2036
	eNB->proc_uespec_rx       = phy_procedures_eNB_uespec_RX;
	eNB->proc_tx              = proc_tx_high;
	eNB->tx_fh                = tx_fh_if4p5;
	eNB->rx_fh                = rx_fh_if4p5;
	eNB->start_rf             = NULL;
	eNB->start_if             = start_if;
        eNB->fh_asynch            = (eNB->node_timing == synch_to_other) ? fh_if4p5_asynch_UL : NULL;
Raymond Knopp's avatar
Raymond Knopp committed
2037 2038
	eNB->rfdevice.host_type   = BBU_HOST;
	eNB->ifdevice.host_type   = BBU_HOST;
2039
        ret = openair0_transport_load(&eNB->ifdevice, &openair0_cfg[CC_id], (eth_params+CC_id));
Raymond Knopp's avatar
Raymond Knopp committed
2040 2041 2042 2043 2044
        printf("openair0_transport_init returns %d for CC_id %d\n",ret,CC_id);
        if (ret<0) {
          printf("Exiting, cannot initialize transport protocol\n");
          exit(-1);
        }
2045
	malloc_IF4p5_buffer(eNB);
Raymond Knopp's avatar
Raymond Knopp committed
2046

2047 2048
	break;
      case NGFI_RAU_IF4p5:
2049
	eNB->do_precoding   = 0;
2050
	eNB->do_prach       = do_prach;
2051
	eNB->fep            = NULL;
2052

hutch's avatar
hutch committed
2053 2054
	eNB->td             = ulsch_decoding_data;//(single_thread_flag==1) ? ulsch_decoding_data_2thread : ulsch_decoding_data;
	eNB->te             = dlsch_encoding;//(single_thread_flag==1) ? dlsch_encoding_2threads : dlsch_encoding;
2055
	eNB->proc_uespec_rx = phy_procedures_eNB_uespec_RX;
2056
	eNB->proc_tx        = proc_tx_high;
2057 2058
	eNB->tx_fh          = tx_fh_if4p5; 
	eNB->rx_fh          = rx_fh_if4p5; 
Raymond Knopp's avatar
Raymond Knopp committed
2059
        eNB->fh_asynch      = (eNB->node_timing == synch_to_other) ? fh_if4p5_asynch_UL : NULL;
2060 2061
	eNB->start_rf       = NULL;
	eNB->start_if       = start_if;
Raymond Knopp's avatar
Raymond Knopp committed
2062 2063 2064

	eNB->rfdevice.host_type   = BBU_HOST;
	eNB->ifdevice.host_type   = BBU_HOST;
2065
        ret = openair0_transport_load(&eNB->ifdevice, &openair0_cfg[CC_id], (eth_params+CC_id));
Raymond Knopp's avatar
Raymond Knopp committed
2066 2067 2068 2069 2070
        printf("openair0_transport_init returns %d for CC_id %d\n",ret,CC_id);
        if (ret<0) {
          printf("Exiting, cannot initialize transport protocol\n");
          exit(-1);
        }
2071
	break;	
Raymond Knopp's avatar
Raymond Knopp committed
2072 2073
	malloc_IF4p5_buffer(eNB);

2074
      }
2075
    }
2076

Florian Kaltenberger's avatar
Florian Kaltenberger committed
2077
    if (setup_eNB_buffers(PHY_vars_eNB_g[inst],&openair0_cfg[0])!=0) {
2078 2079 2080 2081
      printf("Exiting, cannot initialize eNodeB Buffers\n");
      exit(-1);
    }

2082
    init_eNB_proc(inst);
2083
  }
2084

2085 2086 2087
  sleep(1);
  LOG_D(HW,"[lte-softmodem.c] eNB threads created\n");
  
Raymond Knopp's avatar
Raymond Knopp committed
2088

2089 2090 2091
}


2092
void stop_eNB(int nb_inst) {
2093

2094 2095 2096 2097
  for (int inst=0;inst<nb_inst;inst++) {
    printf("Killing eNB %d processing threads\n",inst);
    kill_eNB_proc(inst);
  }
2098
}