lte-ue.c 91.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
 * 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

/*! \file lte-ue.c
 * \brief threads and support functions for real-time LTE UE target
 * \author R. Knopp, F. Kaltenberger, Navid Nikaein
 * \date 2015
 * \version 0.1
 * \company Eurecom
 * \email: knopp@eurecom.fr,florian.kaltenberger@eurecom.fr, navid.nikaein@eurecom.fr
 * \note
 * \warning
 */
32
#include "lte-softmodem.h"
33 34 35

#include "rt_wrapper.h"

Raymond Knopp's avatar
 
Raymond Knopp committed
36
#ifdef OPENAIR2
37 38
#include "LAYER2/MAC/defs.h"
#include "RRC/LITE/extern.h"
Raymond Knopp's avatar
 
Raymond Knopp committed
39
#endif
40
#include "PHY_INTERFACE/phy_stub_UE.h"
41 42 43 44 45 46 47 48 49
#include "PHY_INTERFACE/extern.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 "PHY/extern.h"
#include "SCHED/extern.h"
#include "LAYER2/MAC/extern.h"
#include "LAYER2/MAC/proto.h"
50
#include <inttypes.h>
51 52
//#include "openair2/PHY_INTERFACE/phy_stub_UE.h"

53 54 55 56 57 58 59 60

#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"

61

62 63
#include "T.h"

hbilel's avatar
hbilel committed
64
extern double cpuf;
65
extern uint8_t  nfapi_mode;
hbilel's avatar
hbilel committed
66

67 68
#define FRAME_PERIOD    100000000ULL
#define DAQ_PERIOD      66667ULL
laurent's avatar
laurent committed
69
#define FIFO_PRIORITY   40
70 71

typedef enum {
72 73 74
  pss=0,
  pbch=1,
  si=2
75 76
} sync_mode_t;

77
void init_UE_threads(int);
78
void init_UE_threads_stub(int);
79
void init_UE_single_thread_stub(int);
80
void *UE_thread(void *arg);
81
void init_UE(int nb_inst,int,int,int);
82
void init_UE_stub(int nb_inst,int,int,char*);
83
void init_UE_stub_single_thread(int nb_inst,int,int,char*);
84
extern void oai_subframe_ind(uint16_t sfn, uint16_t sf);
85
//extern int tx_req_UE_MAC1();
86

87 88
void ue_stub_rx_handler(unsigned int, char *);

89 90
int32_t **rxdata;
int32_t **txdata;
91

92 93 94 95
int timer_subframe;
int timer_frame;
SF_ticking *phy_stub_ticking;

96
#define KHz (1000UL)
97
#define MHz (1000*KHz)
98 99

typedef struct eutra_band_s {
100 101 102 103 104 105
  int16_t band;
  uint32_t ul_min;
  uint32_t ul_max;
  uint32_t dl_min;
  uint32_t dl_max;
  lte_frame_type_t frame_type;
106 107 108
} eutra_band_t;

typedef struct band_info_s {
109 110
  int nbands;
  eutra_band_t band_info[100];
111 112 113 114
} band_info_t;

band_info_t bands_to_scan;

115
static const eutra_band_t eutra_bands[] = {
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
  { 1, 1920    * MHz, 1980    * MHz, 2110    * MHz, 2170    * MHz, FDD},
  { 2, 1850    * MHz, 1910    * MHz, 1930    * MHz, 1990    * MHz, FDD},
  { 3, 1710    * MHz, 1785    * MHz, 1805    * MHz, 1880    * MHz, FDD},
  { 4, 1710    * MHz, 1755    * MHz, 2110    * MHz, 2155    * MHz, FDD},
  { 5,  824    * MHz,  849    * MHz,  869    * MHz,  894    * MHz, FDD},
  { 6,  830    * MHz,  840    * MHz,  875    * MHz,  885    * MHz, FDD},
  { 7, 2500    * MHz, 2570    * MHz, 2620    * MHz, 2690    * MHz, FDD},
  { 8,  880    * MHz,  915    * MHz,  925    * MHz,  960    * MHz, FDD},
  { 9, 1749900 * KHz, 1784900 * KHz, 1844900 * KHz, 1879900 * KHz, FDD},
  {10, 1710    * MHz, 1770    * MHz, 2110    * MHz, 2170    * MHz, FDD},
  {11, 1427900 * KHz, 1452900 * KHz, 1475900 * KHz, 1500900 * KHz, FDD},
  {12,  698    * MHz,  716    * MHz,  728    * MHz,  746    * MHz, FDD},
  {13,  777    * MHz,  787    * MHz,  746    * MHz,  756    * MHz, FDD},
  {14,  788    * MHz,  798    * MHz,  758    * MHz,  768    * MHz, FDD},
  {17,  704    * MHz,  716    * MHz,  734    * MHz,  746    * MHz, FDD},
  {20,  832    * MHz,  862    * MHz,  791    * MHz,  821    * MHz, FDD},
  {22, 3510    * MHz, 3590    * MHz, 3410    * MHz, 3490    * MHz, FDD},
  {33, 1900    * MHz, 1920    * MHz, 1900    * MHz, 1920    * MHz, TDD},
  {34, 2010    * MHz, 2025    * MHz, 2010    * MHz, 2025    * MHz, TDD},
  {35, 1850    * MHz, 1910    * MHz, 1850    * MHz, 1910    * MHz, TDD},
  {36, 1930    * MHz, 1990    * MHz, 1930    * MHz, 1990    * MHz, TDD},
  {37, 1910    * MHz, 1930    * MHz, 1910    * MHz, 1930    * MHz, TDD},
  {38, 2570    * MHz, 2620    * MHz, 2570    * MHz, 2630    * MHz, TDD},
  {39, 1880    * MHz, 1920    * MHz, 1880    * MHz, 1920    * MHz, TDD},
  {40, 2300    * MHz, 2400    * MHz, 2300    * MHz, 2400    * MHz, TDD},
  {41, 2496    * MHz, 2690    * MHz, 2496    * MHz, 2690    * MHz, TDD},
  {42, 3400    * MHz, 3600    * MHz, 3400    * MHz, 3600    * MHz, TDD},
  {43, 3600    * MHz, 3800    * MHz, 3600    * MHz, 3800    * MHz, TDD},
  {44, 703    * MHz, 803    * MHz, 703    * MHz, 803    * MHz, TDD},
145 146
};

147 148


149

150 151 152 153
pthread_t                       main_ue_thread;
pthread_attr_t                  attr_UE_thread;
struct sched_param              sched_param_UE_thread;

154
void phy_init_lte_ue_transport(PHY_VARS_UE *ue,int absraction_flag);
155

156 157 158
PHY_VARS_UE* init_ue_vars(LTE_DL_FRAME_PARMS *frame_parms,
			  uint8_t UE_id,
			  uint8_t abstraction_flag)
159 160 161

{

162 163
  PHY_VARS_UE* ue;

164
  if (frame_parms!=(LTE_DL_FRAME_PARMS *)NULL) { // if we want to give initial frame parms, allocate the PHY_VARS_UE structure and put them in
165 166 167
    ue = (PHY_VARS_UE *)malloc(sizeof(PHY_VARS_UE));
    memset(ue,0,sizeof(PHY_VARS_UE));
    memcpy(&(ue->frame_parms), frame_parms, sizeof(LTE_DL_FRAME_PARMS));
168
  }
169 170
  else ue = PHY_vars_UE_g[UE_id][0];

171 172 173

  ue->Mod_id      = UE_id;
  ue->mac_enabled = 1;
174 175 176

  // Panos: In phy_stub_UE (MAC-to-MAC) mode these init functions don't need to get called. Is this correct?
  if (nfapi_mode!=3)
177 178 179 180 181 182
    {
      // initialize all signal buffers
      init_lte_ue_signal(ue,1,abstraction_flag);
      // intialize transport
      init_lte_ue_transport(ue,abstraction_flag);
    }
183 184

  return(ue);
185 186
}

187

188 189
char uecap_xer[1024];

190 191


laurent's avatar
laurent committed
192
void init_thread(int sched_runtime, int sched_deadline, int sched_fifo, cpu_set_t *cpuset, char * name) {
193

laurent's avatar
laurent committed
194
#ifdef DEADLINE_SCHEDULER
195 196 197 198 199 200 201 202 203 204 205 206
  if (sched_runtime!=0) {
    struct sched_attr attr= {0};
    attr.size = sizeof(attr);
    attr.sched_policy = SCHED_DEADLINE;
    attr.sched_runtime  = sched_runtime;
    attr.sched_deadline = sched_deadline;
    attr.sched_period   = 0;
    AssertFatal(sched_setattr(0, &attr, 0) == 0,
		"[SCHED] %s thread: sched_setattr failed %s \n", name, strerror(errno));
    LOG_I(HW,"[SCHED][eNB] %s deadline thread %lu started on CPU %d\n",
	  name, (unsigned long)gettid(), sched_getcpu());
  }
laurent's avatar
laurent committed
207
#else
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
  if (CPU_COUNT(cpuset) > 0)
    AssertFatal( 0 == pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), cpuset), "");
  struct sched_param sp;
  sp.sched_priority = sched_fifo;
  AssertFatal(pthread_setschedparam(pthread_self(),SCHED_FIFO,&sp)==0,
	      "Can't set thread priority, Are you root?\n");
  /* Check the actual affinity mask assigned to the thread */
  cpu_set_t *cset=CPU_ALLOC(CPU_SETSIZE);
  if (0 == pthread_getaffinity_np(pthread_self(), CPU_ALLOC_SIZE(CPU_SETSIZE), cset)) {
    char txt[512]={0};
    for (int j = 0; j < CPU_SETSIZE; j++)
      if (CPU_ISSET(j, cset))
	sprintf(txt+strlen(txt), " %d ", j);
    printf("CPU Affinity of thread %s is %s\n", name, txt);
  }
  CPU_FREE(cset);
224 225
#endif

laurent's avatar
laurent committed
226
}
227

228
void init_UE(int nb_inst,int eMBMS_active, int uecap_xer_in, int timing_correction) {
229

Raymond Knopp's avatar
Raymond Knopp committed
230
  PHY_VARS_UE *UE;
231 232
  int         inst;
  int         ret;
Raymond Knopp's avatar
Raymond Knopp committed
233

234
  LOG_I(PHY,"UE : Calling Layer 2 for initialization\n");
235

236 237 238
  l2_init_ue(eMBMS_active,(uecap_xer_in==1)?uecap_xer:NULL,
	     0,// cba_group_active
	     0); // HO flag
239

Raymond Knopp's avatar
Raymond Knopp committed
240
  for (inst=0;inst<nb_inst;inst++) {
241

242
    LOG_I(PHY,"Initializing memory for UE instance %d (%p)\n",inst,PHY_vars_UE_g[inst]);
243
    PHY_vars_UE_g[inst][0] = init_ue_vars(NULL,inst,0);
244 245
    // turn off timing control loop in UE
    PHY_vars_UE_g[inst][0]->no_timing_correction = timing_correction;
246

247
    LOG_I(PHY,"Intializing UE Threads for instance %d (%p,%p)...\n",inst,PHY_vars_UE_g[inst],PHY_vars_UE_g[inst][0]);
Raymond Knopp's avatar
Raymond Knopp committed
248 249
    init_UE_threads(inst);
    UE = PHY_vars_UE_g[inst][0];
Raymond Knopp's avatar
Raymond Knopp committed
250

251 252 253 254 255
    if (oaisim_flag == 0) {
      ret = openair0_device_load(&(UE->rfdevice), &openair0_cfg[0]);
      if (ret !=0){
	exit_fun("Error loading device library");
      }
Rohit Gupta's avatar
Rohit Gupta committed
256
    }
257
    UE->rfdevice.host_type = RAU_HOST;
Raymond Knopp's avatar
Raymond Knopp committed
258
    //    UE->rfdevice.type      = NONE_DEV;
259 260 261 262 263
    PHY_VARS_UE *UE = PHY_vars_UE_g[inst][0];
    AssertFatal(0 == pthread_create(&UE->proc.pthread_ue,
                                    &UE->proc.attr_ue,
                                    UE_thread,
                                    (void*)UE), "");
264 265
  }

266
  printf("UE threads created by %ld\n", gettid());
267 268
#if 0
#if defined(ENABLE_USE_MME)
269
  extern volatile int start_UE;
270 271 272 273
  while (start_UE == 0) {
    sleep(1);
  }
#endif
274
#endif
275 276
}

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
// Panos: Initiating all UEs within a single set of threads for PHY_STUB. Future extensions -> multiple
// set of threads for multiple UEs.
void init_UE_stub_single_thread(int nb_inst,int eMBMS_active, int uecap_xer_in, char *emul_iface) {

  int         inst;

  LOG_I(PHY,"UE : Calling Layer 2 for initialization, nb_inst: %d \n", nb_inst);

  l2_init_ue(eMBMS_active,(uecap_xer_in==1)?uecap_xer:NULL,
	     0,// cba_group_active
	     0); // HO flag

  for (inst=0;inst<nb_inst;inst++) {

    LOG_I(PHY,"Initializing memory for UE instance %d (%p)\n",inst,PHY_vars_UE_g[inst]);
    PHY_vars_UE_g[inst][0] = init_ue_vars(NULL,inst,0);
  }
  init_timer_thread();
  init_UE_single_thread_stub(nb_inst);

  /*for (inst=0;inst<nb_inst;inst++) {

    LOG_I(PHY,"Intializing UE Threads for instance %d (%p,%p)...\n",inst,PHY_vars_UE_g[inst],PHY_vars_UE_g[inst][0]);
    init_UE_threads_stub(inst);
  }*/

  printf("UE threads created \n");

  LOG_I(PHY,"Starting multicast link on %s\n",emul_iface);
  if(nfapi_mode!=3)
  multicast_link_start(ue_stub_rx_handler,0,emul_iface);


}




315

316
void init_UE_stub(int nb_inst,int eMBMS_active, int uecap_xer_in, char *emul_iface) {
317 318 319 320 321 322 323 324 325 326 327 328 329

  int         inst;

  LOG_I(PHY,"UE : Calling Layer 2 for initialization\n");

  l2_init_ue(eMBMS_active,(uecap_xer_in==1)?uecap_xer:NULL,
	     0,// cba_group_active
	     0); // HO flag

  for (inst=0;inst<nb_inst;inst++) {

    LOG_I(PHY,"Initializing memory for UE instance %d (%p)\n",inst,PHY_vars_UE_g[inst]);
    PHY_vars_UE_g[inst][0] = init_ue_vars(NULL,inst,0);
330 331 332 333
  }
  init_timer_thread();

  for (inst=0;inst<nb_inst;inst++) {
334 335 336 337 338 339

    LOG_I(PHY,"Intializing UE Threads for instance %d (%p,%p)...\n",inst,PHY_vars_UE_g[inst],PHY_vars_UE_g[inst][0]);
    init_UE_threads_stub(inst);
  }

  printf("UE threads created \n");
340

341
  LOG_I(PHY,"Starting multicast link on %s\n",emul_iface);
342
  if(nfapi_mode !=3)
343
     multicast_link_start(ue_stub_rx_handler,0,emul_iface);
344 345


346

347 348 349 350 351
}




352 353
/*!
 * \brief This is the UE synchronize thread.
354
 * It performs band scanning and synchonization.
355 356 357
 * \param arg is a pointer to a \ref PHY_VARS_UE structure.
 * \returns a pointer to an int. The storage is not on the heap and must not be freed.
 */
laurent's avatar
laurent committed
358

359 360
static void *UE_thread_synch(void *arg)
{
361 362 363
  static int UE_thread_synch_retval;
  int i, hw_slot_offset;
  PHY_VARS_UE *UE = (PHY_VARS_UE*) arg;
364 365
  int current_band = 0;
  int current_offset = 0;
366
  sync_mode_t sync_mode = pbch;
367
  int CC_id = UE->CC_id;
368 369
  int ind;
  int found;
370
  int freq_offset=0;
371
  char threadname[128];
372 373 374

  UE->is_synchronized = 0;
  printf("UE_thread_sync in with PHY_vars_UE %p\n",arg);
375

376
  cpu_set_t cpuset;
377
  CPU_ZERO(&cpuset);
378 379 380 381 382
  if ( threads.iq != -1 )
    CPU_SET(threads.iq, &cpuset);
  // this thread priority must be lower that the main acquisition thread
  sprintf(threadname, "sync UE %d\n", UE->Mod_id);
  init_thread(100000, 500000, FIFO_PRIORITY-1, &cpuset, threadname);
383

384
  printf("starting UE synch thread (IC %d)\n",UE->proc.instance_cnt_synch);
385 386
  ind = 0;
  found = 0;
387 388


389 390
  if (UE->UE_scan == 0) {
    do  {
391
      current_band = eutra_bands[ind].band;
Raymond Knopp's avatar
 
Raymond Knopp committed
392
      printf( "Scanning band %d, dl_min %"PRIu32", ul_min %"PRIu32"\n", current_band, eutra_bands[ind].dl_min,eutra_bands[ind].ul_min);
393

394
      if ((eutra_bands[ind].dl_min <= UE->frame_parms.dl_CarrierFreq) && (eutra_bands[ind].dl_max >= UE->frame_parms.dl_CarrierFreq)) {
395 396
	for (i=0; i<4; i++)
	  uplink_frequency_offset[CC_id][i] = eutra_bands[ind].ul_min - eutra_bands[ind].dl_min;
397 398 399 400

        found = 1;
        break;
      }
401

402
      ind++;
403
    } while (ind < sizeof(eutra_bands) / sizeof(eutra_bands[0]));
404

405
    if (found == 0) {
Florian Kaltenberger's avatar
Florian Kaltenberger committed
406
      LOG_E(PHY,"Can't find EUTRA band for frequency %d",UE->frame_parms.dl_CarrierFreq);
407
      exit_fun("Can't find EUTRA band for frequency");
408
      return &UE_thread_synch_retval;
409
    }
410

411

412
    LOG_I( PHY, "[SCHED][UE] Check absolute frequency DL %"PRIu32", UL %"PRIu32" (oai_exit %d, rx_num_channels %d)\n", UE->frame_parms.dl_CarrierFreq, UE->frame_parms.ul_CarrierFreq,oai_exit, openair0_cfg[0].rx_num_channels);
413

414
    for (i=0;i<openair0_cfg[UE->rf_map.card].rx_num_channels;i++) {
415 416
      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = UE->frame_parms.dl_CarrierFreq;
      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = UE->frame_parms.ul_CarrierFreq;
417
      openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
418
      if (uplink_frequency_offset[CC_id][i] != 0) //
419
	openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_FDD;
420
      else //FDD
421
	openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_TDD;
422 423
    }

424
    sync_mode = pbch;
425

426
  } else if  (UE->UE_scan == 1) {
427
    current_band=0;
428

429 430
    for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
      downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[CC_id].dl_min;
431 432
      uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] =
	bands_to_scan.band_info[CC_id].ul_min-bands_to_scan.band_info[CC_id].dl_min;
433
      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
434 435
      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
	downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
436
      openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
437 438
    }
  }
439

440 441 442
  while (sync_var<0)
    pthread_cond_wait(&sync_cond, &sync_mutex);
  pthread_mutex_unlock(&sync_mutex);
Raymond Knopp's avatar
Raymond Knopp committed
443

444
  printf("Started device, unlocked sync_mutex (UE_sync_thread)\n");
445

446 447 448
  if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) {
    LOG_E(HW,"Could not start the device\n");
    oai_exit=1;
Raymond Knopp's avatar
Raymond Knopp committed
449 450
  }

451
  while (oai_exit==0) {
452 453
    AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
    while (UE->proc.instance_cnt_synch < 0)
454
      // the thread waits here most of the time
455
      pthread_cond_wait( &UE->proc.cond_synch, &UE->proc.mutex_synch );
456
    AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
457

458
    switch (sync_mode) {
459
    case pss:
460 461
      LOG_I(PHY,"[SCHED][UE] Scanning band %d (%d), freq %u\n",bands_to_scan.band_info[current_band].band, current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
      lte_sync_timefreq(UE,current_band,bands_to_scan.band_info[current_band].dl_min+current_offset);
462
      current_offset += 20000000; // increase by 20 MHz
463

464
      if (current_offset > bands_to_scan.band_info[current_band].dl_max-bands_to_scan.band_info[current_band].dl_min) {
465
	current_band++;
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
	current_offset=0;
      }

      if (current_band==bands_to_scan.nbands) {
	current_band=0;
	oai_exit=1;
      }

      for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
	downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].dl_min+current_offset;
	uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].ul_min-bands_to_scan.band_info[0].dl_min + current_offset;

	openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
	openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
	openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
	if (UE->UE_scan_carrier) {
	  openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
	}
      }
485

486
      break;
487

488
    case pbch:
489

Cedric Roux's avatar
Cedric Roux committed
490
#if DISABLE_LOG_X
491
      printf("[UE thread Synch] Running Initial Synch (mode %d)\n",UE->mode);
Cedric Roux's avatar
Cedric Roux committed
492
#else
493
      LOG_I(PHY, "[UE thread Synch] Running Initial Synch (mode %d)\n",UE->mode);
Cedric Roux's avatar
Cedric Roux committed
494
#endif
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
      if (initial_sync( UE, UE->mode ) == 0) {

	hw_slot_offset = (UE->rx_offset<<1) / UE->frame_parms.samples_per_tti;
	LOG_I( HW, "Got synch: hw_slot_offset %d, carrier off %d Hz, rxgain %d (DL %u, UL %u), UE_scan_carrier %d\n",
	       hw_slot_offset,
	       freq_offset,
	       UE->rx_total_gain_dB,
	       downlink_frequency[0][0]+freq_offset,
	       downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset,
	       UE->UE_scan_carrier );


	// rerun with new cell parameters and frequency-offset
	for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
	  openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
	  if (UE->UE_scan_carrier == 1) {
	    if (freq_offset >= 0)
	      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] += abs(UE->common_vars.freq_offset);
	    else
	      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] -= abs(UE->common_vars.freq_offset);
	    openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
	      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i]+uplink_frequency_offset[CC_id][i];
	    downlink_frequency[CC_id][i] = openair0_cfg[CC_id].rx_freq[i];
	    freq_offset=0;
519
	  }
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
	}

	// reconfigure for potentially different bandwidth
	switch(UE->frame_parms.N_RB_DL) {
	case 6:
	  openair0_cfg[UE->rf_map.card].sample_rate =1.92e6;
	  openair0_cfg[UE->rf_map.card].rx_bw          =.96e6;
	  openair0_cfg[UE->rf_map.card].tx_bw          =.96e6;
	  //            openair0_cfg[0].rx_gain[0] -= 12;
	  break;
	case 25:
	  openair0_cfg[UE->rf_map.card].sample_rate =7.68e6;
	  openair0_cfg[UE->rf_map.card].rx_bw          =2.5e6;
	  openair0_cfg[UE->rf_map.card].tx_bw          =2.5e6;
	  //            openair0_cfg[0].rx_gain[0] -= 6;
	  break;
	case 50:
	  openair0_cfg[UE->rf_map.card].sample_rate =15.36e6;
	  openair0_cfg[UE->rf_map.card].rx_bw          =5.0e6;
	  openair0_cfg[UE->rf_map.card].tx_bw          =5.0e6;
	  //            openair0_cfg[0].rx_gain[0] -= 3;
	  break;
	case 100:
	  openair0_cfg[UE->rf_map.card].sample_rate=30.72e6;
	  openair0_cfg[UE->rf_map.card].rx_bw=10.0e6;
	  openair0_cfg[UE->rf_map.card].tx_bw=10.0e6;
	  //            openair0_cfg[0].rx_gain[0] -= 0;
	  break;
	}

	UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
	//UE->rfdevice.trx_set_gains_func(&openair0,&openair0_cfg[0]);
	//UE->rfdevice.trx_stop_func(&UE->rfdevice);
	sleep(1);
	init_frame_parms(&UE->frame_parms,1);
	/*if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) {
	  LOG_E(HW,"Could not start the device\n");
	  oai_exit=1;
	  }*/

	if (UE->UE_scan_carrier == 1) {

	  UE->UE_scan_carrier = 0;
	} else {
	  AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
	  UE->is_synchronized = 1;
	  AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");

	  if( UE->mode == rx_dump_frame ) {
	    FILE *fd;
	    if ((UE->proc.proc_rxtx[0].frame_rx&1) == 0) {  // this guarantees SIB1 is present
	      if ((fd = fopen("rxsig_frame0.dat","w")) != NULL) {
		fwrite((void*)&UE->common_vars.rxdata[0][0],
		       sizeof(int32_t),
		       10*UE->frame_parms.samples_per_tti,
		       fd);
		LOG_I(PHY,"Dummping Frame ... bye bye \n");
		fclose(fd);
		exit(0);
	      } else {
		LOG_E(PHY,"Cannot open file for writing\n");
		exit(0);
	      }
	    } else {
	      AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
	      UE->is_synchronized = 0;
	      AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
587

588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
	    }
	  }
	}
      } else {
	// initial sync failed
	// calculate new offset and try again
	if (UE->UE_scan_carrier == 1) {
	  if (freq_offset >= 0)
	    freq_offset += 100;
	  freq_offset *= -1;

	  if (abs(freq_offset) > 7500) {
	    LOG_I( PHY, "[initial_sync] No cell synchronization found, abandoning\n" );
	    FILE *fd;
	    if ((fd = fopen("rxsig_frame0.dat","w"))!=NULL) {
	      fwrite((void*)&UE->common_vars.rxdata[0][0],
		     sizeof(int32_t),
		     10*UE->frame_parms.samples_per_tti,
		     fd);
	      LOG_I(PHY,"Dummping Frame ... bye bye \n");
	      fclose(fd);
	      exit(0);
	    }
	    AssertFatal(1==0,"No cell synchronization found, abandoning");
	    return &UE_thread_synch_retval; // not reached
	  }
	}
Cedric Roux's avatar
Cedric Roux committed
615
#if DISABLE_LOG_X
616 617 618 619 620
	printf("[initial_sync] trying carrier off %d Hz, rxgain %d (DL %u, UL %u)\n",
	       freq_offset,
	       UE->rx_total_gain_dB,
	       downlink_frequency[0][0]+freq_offset,
	       downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset );
Cedric Roux's avatar
Cedric Roux committed
621
#else
622 623 624 625 626
	LOG_I(PHY, "[initial_sync] trying carrier off %d Hz, rxgain %d (DL %u, UL %u)\n",
	      freq_offset,
	      UE->rx_total_gain_dB,
	      downlink_frequency[0][0]+freq_offset,
	      downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset );
Cedric Roux's avatar
Cedric Roux committed
627
#endif
laurent's avatar
laurent committed
628

629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
	for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
	  openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+freq_offset;
	  openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i]+freq_offset;
	  openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
	  if (UE->UE_scan_carrier==1)
	    openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
	}
	UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0],0);
      }// initial_sync=0
      break;
    case si:
    default:
      break;
    }

    AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
    // indicate readiness
    UE->proc.instance_cnt_synch--;
    AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");

    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_SYNCH, 0 );
  }  // while !oai_exit

  return &UE_thread_synch_retval;
653 654
}

655
/*!
656
 * \brief This is the UE thread for RX subframe n and TX subframe n+4.
657
 * This thread performs the phy_procedures_UE_RX() on every received slot.
laurent's avatar
laurent committed
658
 * then, if TX is enabled it performs TX for n+4.
659 660 661
 * \param arg is a pointer to a \ref PHY_VARS_UE structure.
 * \returns a pointer to an int. The storage is not on the heap and must not be freed.
 */
662

laurent's avatar
laurent committed
663
static void *UE_thread_rxn_txnp4(void *arg) {
664 665 666 667 668 669 670 671 672 673 674 675 676
  static __thread int UE_thread_rxtx_retval;
  struct rx_tx_thread_data *rtd = arg;
  UE_rxtx_proc_t *proc = rtd->proc;
  PHY_VARS_UE    *UE   = rtd->UE;
  int ret;

  proc->instance_cnt_rxtx=-1;
  proc->subframe_rx=proc->sub_frame_start;

  char threadname[256];
  sprintf(threadname,"UE_%d_proc_%d", UE->Mod_id, proc->sub_frame_start);
  cpu_set_t cpuset;
  CPU_ZERO(&cpuset);
laurent's avatar
laurent committed
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 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
  if ( (proc->sub_frame_start+1)%RX_NB_TH == 0 && threads.one != -1 )
    CPU_SET(threads.one, &cpuset);
  if ( (proc->sub_frame_start+1)%RX_NB_TH == 1 && threads.two != -1 )
    CPU_SET(threads.two, &cpuset);
  if ( (proc->sub_frame_start+1)%RX_NB_TH == 2 && threads.three != -1 )
    CPU_SET(threads.three, &cpuset);
  //CPU_SET(threads.three, &cpuset);
  init_thread(900000,1000000 , FIFO_PRIORITY-1, &cpuset,
	      threadname);

  while (!oai_exit) {
    if (pthread_mutex_lock(&proc->mutex_rxtx) != 0) {
      LOG_E( PHY, "[SCHED][UE] error locking mutex for UE RXTX\n" );
      exit_fun("nothing to add");
    }
    while (proc->instance_cnt_rxtx < 0) {
      // most of the time, the thread is waiting here
      pthread_cond_wait( &proc->cond_rxtx, &proc->mutex_rxtx );
    }
    if (pthread_mutex_unlock(&proc->mutex_rxtx) != 0) {
      LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE RXn_TXnp4\n" );
      exit_fun("nothing to add");
    }

    initRefTimes(t2);
    initRefTimes(t3);
    pickTime(current);
    updateTimes(proc->gotIQs, &t2, 10000, "Delay to wake up UE_Thread_Rx (case 2)");

    // Process Rx data for one sub-frame
    lte_subframe_t sf_type = subframe_select( &UE->frame_parms, proc->subframe_rx);
    if ((sf_type == SF_DL) ||
	(UE->frame_parms.frame_type == FDD) ||
	(sf_type == SF_S)) {

      if (UE->frame_parms.frame_type == TDD) {
	LOG_D(PHY, "%s,TDD%d,%s: calling UE_RX\n",
	      threadname,
	      UE->frame_parms.tdd_config,
	      (sf_type==SF_DL? "SF_DL" :
	       (sf_type==SF_UL? "SF_UL" :
		(sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
      } else {
	LOG_D(PHY, "%s,%s,%s: calling UE_RX\n",
	      threadname,
	      (UE->frame_parms.frame_type==FDD? "FDD":
	       (UE->frame_parms.frame_type==TDD? "TDD":"UNKNOWN_DUPLEX_MODE")),
	      (sf_type==SF_DL? "SF_DL" :
	       (sf_type==SF_UL? "SF_UL" :
		(sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
      }
729
#ifdef UE_SLOT_PARALLELISATION
730
      phy_procedures_slot_parallelization_UE_RX( UE, proc, 0, 0, 1, UE->mode, no_relay, NULL );
731
#else
732
      phy_procedures_UE_RX( UE, proc, 0, 0, 1, UE->mode, no_relay, NULL );
733
#endif
734
    }
735 736

#if UE_TIMING_TRACE
737
    start_meas(&UE->generic_stat);
738
#endif
739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
    if (UE->mac_enabled==1) {

      ret = ue_scheduler(UE->Mod_id,
			 proc->frame_rx,
			 proc->subframe_rx,
			 proc->frame_tx,
			 proc->subframe_tx,
			 subframe_select(&UE->frame_parms,proc->subframe_tx),
			 0,
			 0/*FIXME CC_id*/);
      if ( ret != CONNECTION_OK) {
	char *txt;
	switch (ret) {
	case CONNECTION_LOST:
	  txt="RRC Connection lost, returning to PRACH";
	  break;
	case PHY_RESYNCH:
	  txt="RRC Connection lost, trying to resynch";
	  break;
	case RESYNCH:
	  txt="return to PRACH and perform a contention-free access";
	  break;
	default:
	  txt="UNKNOWN RETURN CODE";
	};
	LOG_E( PHY, "[UE %"PRIu8"] Frame %"PRIu32", subframe %u %s\n",
	       UE->Mod_id, proc->frame_rx, proc->subframe_tx,txt );
      }
    }
768
#if UE_TIMING_TRACE
769
    stop_meas(&UE->generic_stat);
770 771 772
#endif


773
    // Prepare the future Tx data
774

775 776 777 778
    if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_UL) ||
	(UE->frame_parms.frame_type == FDD) )
      if (UE->mode != loop_through_memory)
	phy_procedures_UE_TX(UE,proc,0,0,UE->mode,no_relay);
779 780 781



782 783 784 785 786
    if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_S) &&
	(UE->frame_parms.frame_type == TDD))
      if (UE->mode != loop_through_memory)
	phy_procedures_UE_S_TX(UE,0,0,no_relay);
    updateTimes(current, &t3, 10000, "Delay to process sub-frame (case 3)");
787

788 789 790
    if (pthread_mutex_lock(&proc->mutex_rxtx) != 0) {
      LOG_E( PHY, "[SCHED][UE] error locking mutex for UE RXTX\n" );
      exit_fun("noting to add");
791
    }
792 793 794 795 796 797
    proc->instance_cnt_rxtx--;
    if (pthread_mutex_unlock(&proc->mutex_rxtx) != 0) {
      LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE RXTX\n" );
      exit_fun("noting to add");
    }
  }
798

799 800 801
  // thread finished
  free(arg);
  return &UE_thread_rxtx_retval;
802 803 804 805
}



806
unsigned int emulator_absSF;
807

808 809 810 811 812
void ue_stub_rx_handler(unsigned int num_bytes, char *rx_buffer) {

  PHY_VARS_UE *UE;
  UE = PHY_vars_UE_g[0][0];

Raymond Knopp's avatar
Raymond Knopp committed
813 814
  UE_tport_t *pdu = (UE_tport_t*)rx_buffer;
  SLSCH_t *slsch = (SLSCH_t*)&pdu->slsch;
815
  SLDCH_t *sldch = (SLDCH_t*)&pdu->sldch;
816

817 818 819 820 821 822
  switch (((UE_tport_header_t*)rx_buffer)->packet_type) {
  case TTI_SYNC:
    emulator_absSF = ((UE_tport_header_t*)rx_buffer)->absSF;
    wakeup_thread(&UE->timer_mutex,&UE->timer_cond,&UE->instance_cnt_timer,"timer_thread");
    break;
  case SLSCH:
823 824


Raymond Knopp's avatar
Raymond Knopp committed
825 826 827 828 829 830 831
    LOG_I(PHY,"Emulator SFN.SF %d.%d, Got SLSCH packet\n",emulator_absSF/10,emulator_absSF%10);
    LOG_I(PHY,"Received %d bytes on UE-UE link for SFN.SF %d.%d, sending SLSCH payload (%d bytes) to MAC\n",num_bytes,
	  pdu->header.absSF/10,pdu->header.absSF%10,
	  slsch->payload_length);
    printf("SLSCH:");
    for (int i=0;i<sizeof(SLSCH_t);i++) printf("%x ",((uint8_t*)slsch)[i]);
    printf("\n");
832

Raymond Knopp's avatar
Raymond Knopp committed
833 834 835 836 837 838
    ue_send_sl_sdu(0,
		   0,
		   pdu->header.absSF/10,
		   pdu->header.absSF%10,
		   pdu->payload,
		   slsch->payload_length,
839 840
		   0,
		   SL_DISCOVERY_FLAG_NO);
841
    break;
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857

  case SLDCH:


    LOG_I(PHY,"Emulator SFN.SF %d.%d, Got SLDCH packet\n",emulator_absSF/10,emulator_absSF%10);
    LOG_I(PHY,"Received %d bytes on UE-UE link for SFN.SF %d.%d, sending SLDCH payload (%d bytes) to MAC\n",num_bytes,
          pdu->header.absSF/10,pdu->header.absSF%10,
          sldch->payload_length);
    printf("SLDCH:");
    for (int i=0;i<sizeof(SLDCH_t);i++) printf("%x ",((uint8_t*)sldch)[i]);
    printf("\n");

    ue_send_sl_sdu(0,
                   0,
                   pdu->header.absSF/10,
                   pdu->header.absSF%10,
858
                   sldch->payload,
859 860 861 862 863
                   sldch->payload_length,
                   0,
                   SL_DISCOVERY_FLAG_YES);
    break;

864 865
  }
}
866

867 868 869 870 871 872 873 874 875 876 877 878 879 880

/*!
 * \brief This is the UE thread for RX subframe n and TX subframe n+4.
 * This thread performs the phy_procedures_UE_RX() on every received slot.
 * then, if TX is enabled it performs TX for n+4.
 * \param arg is a pointer to a \ref PHY_VARS_UE structure.
 * \returns a pointer to an int. The storage is not on the heap and must not be freed.
 */

static void *UE_phy_stub_single_thread_rxn_txnp4(void *arg) {

	thread_top_init("UE_phy_stub_thread_rxn_txnp4",1,870000L,1000000L,1000000L);

	module_id_t Mod_id = 0;
881
	//int init_ra_UE = -1; // This counter is used to initiate the RA of each UE in different SFrames
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
  static __thread int UE_thread_rxtx_retval;
  struct rx_tx_thread_data *rtd = arg;
  UE_rxtx_proc_t *proc = rtd->proc;

  PHY_VARS_UE    *UE;   //= rtd->UE;
  int ret;
  //  double t_diff;

  char threadname[256];
  //sprintf(threadname,"UE_%d_proc", UE->Mod_id);

  // Panos: Call (Sched_Rsp_t) get_nfapi_sched_response(UE->Mod_ID) to get all
  //sched_response config messages which concern the specific UE. Inside this
  //function we should somehow make the translation of rnti to Mod_ID.

  //proc->instance_cnt_rxtx=-1;

  phy_stub_ticking->ticking_var = -1;
  proc->subframe_rx=proc->sub_frame_start;

  // Initialize all nfapi structures to NULL
903
  /*for (Mod_id=0; Mod_id<NB_UE_INST; Mod_id++) {
904 905 906
      	UE_mac_inst[Mod_id].dl_config_req = NULL;
      	UE_mac_inst[Mod_id].ul_config_req = NULL;
      	UE_mac_inst[Mod_id].hi_dci0_req = NULL;
907 908 909
      	//UE_mac_inst[Mod_id].ra_frame = 0;
      	next_ra_frame = 0;
      	next_Mod_id = 0;
910 911 912
      	tx_request_pdu_list = NULL;
      	tx_req_num_elems = 0;
      	UE_mac_inst[Mod_id].tx_req = NULL;
913
      }*/
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954

  //PANOS: CAREFUL HERE!
  wait_sync("UE_phy_stub_single_thread_rxn_txnp4");

  while (!oai_exit) {

    if (pthread_mutex_lock(&phy_stub_ticking->mutex_ticking) != 0) {
      LOG_E( MAC, "[SCHED][UE] error locking mutex for UE RXTX\n" );
      exit_fun("nothing to add");
    }
    while (phy_stub_ticking->ticking_var < 0) {
      // most of the time, the thread is waiting here
      //pthread_cond_wait( &proc->cond_rxtx, &proc->mutex_rxtx )
      LOG_D(MAC,"Waiting for ticking_var\n");
      pthread_cond_wait( &phy_stub_ticking->cond_ticking, &phy_stub_ticking->mutex_ticking);
    }
    phy_stub_ticking->ticking_var--;
    if (pthread_mutex_unlock(&phy_stub_ticking->mutex_ticking) != 0) {
      LOG_E( MAC, "[SCHED][UE] error unlocking mutex for UE RXn_TXnp4\n" );
      exit_fun("nothing to add");
    }
    LOG_D(MAC," Panos-D [UE_phy_stub_thread_rxn_txnp4 1] Frame: %d, Subframe: %d \n" "\n" "\n", timer_frame, timer_subframe);


    proc->subframe_rx=timer_subframe;
    proc->frame_rx = timer_frame;
    proc->subframe_tx=(timer_subframe+4)%10;
    proc->frame_tx = proc->frame_rx + (proc->subframe_rx>5?1:0);
    //oai_subframe_ind(proc->frame_rx, proc->subframe_rx);


    oai_subframe_ind(timer_frame, timer_subframe);

    // Panos: Guessing that the next 4 lines are not needed for the phy_stub mode.
    /*initRefTimes(t2);
      initRefTimes(t3);
      pickTime(current);
      updateTimes(proc->gotIQs, &t2, 10000, "Delay to wake up UE_Thread_Rx (case 2)");*/


    //if(timer_frame%5 == 0 && timer_subframe%10 == 0)
955
    	//init_ra_UE++;
956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980

    	//Panos: Not sure whether we should put the memory allocation here.
    	//*** Note we should find the right place to call free(UL_INFO).
    	UL_INFO = (UL_IND_t*)malloc(sizeof(UL_IND_t));

    	UL_INFO->rx_ind.rx_indication_body.rx_pdu_list = (nfapi_rx_indication_pdu_t*)malloc(10*sizeof(nfapi_rx_indication_pdu_t));
    	UL_INFO->rx_ind.rx_indication_body.number_of_pdus = 0;
    	UL_INFO->rx_ind.header.message_id = 3225;


    	UL_INFO->crc_ind.crc_indication_body.crc_pdu_list = (nfapi_crc_indication_pdu_t*)malloc(10*sizeof(nfapi_crc_indication_pdu_t));
    	UL_INFO->crc_ind.crc_indication_body.number_of_crcs = 0;
    	UL_INFO->crc_ind.header.message_id = 3225;

    	UL_INFO->harq_ind.harq_indication_body.harq_pdu_list = (nfapi_harq_indication_pdu_t*)malloc(10*sizeof(nfapi_harq_indication_pdu_t));
    	UL_INFO->harq_ind.harq_indication_body.number_of_harqs = 0;
    	UL_INFO->harq_ind.header.message_id = 3225;

    	UL_INFO->sr_ind.sr_indication_body.sr_pdu_list = (nfapi_sr_indication_pdu_t*)malloc(10*sizeof(nfapi_sr_indication_pdu_t));
    	UL_INFO->sr_ind.sr_indication_body.number_of_srs = 0;
    	UL_INFO->sr_ind.header.message_id = 3225;




981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
    for (Mod_id=0; Mod_id<NB_UE_INST; Mod_id++) {
    	//LOG_I(MAC, "Panos-D: UE_phy_stub_single_thread_rxn_txnp4, NB_UE_INST:%d, Mod_id:%d \n", NB_UE_INST, Mod_id);
    	UE = PHY_vars_UE_g[Mod_id][0];
    lte_subframe_t sf_type = subframe_select( &UE->frame_parms, proc->subframe_rx);
    if ((sf_type == SF_DL) ||
	(UE->frame_parms.frame_type == FDD) ||
	(sf_type == SF_S)) {

      if (UE->frame_parms.frame_type == TDD) {
	LOG_D(PHY, "%s,TDD%d,%s: calling UE_RX\n",
	      threadname,
	      UE->frame_parms.tdd_config,
	      (sf_type==SF_DL? "SF_DL" :
	       (sf_type==SF_UL? "SF_UL" :
		(sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
      } else {
	LOG_D(PHY, "%s,%s,%s: calling UE_RX\n",
	      threadname,
	      (UE->frame_parms.frame_type==FDD? "FDD":
	       (UE->frame_parms.frame_type==TDD? "TDD":"UNKNOWN_DUPLEX_MODE")),
	      (sf_type==SF_DL? "SF_DL" :
	       (sf_type==SF_UL? "SF_UL" :
		(sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
      }


      phy_procedures_UE_SL_RX(UE,proc);



      /*
	#ifdef UE_SLOT_PARALLELISATION
	phy_procedures_slot_parallelization_UE_RX( UE, proc, 0, 0, 1, UE->mode, no_relay, NULL );
	#else
      */
      // Panos: Substitute call to phy_procedures Rx with call to phy_stub functions in order to trigger
      // UE Rx procedures directly at the MAC layer, based on the received nfapi requests from the vnf (eNB).
      // Hardcode Mod_id for now. Will be changed later.

      // Panos: is this the right place to call oai_subframe_indication to invoke p7 nfapi callbacks here?

      //oai_subframe_ind(proc->frame_rx, proc->subframe_rx);
      //oai_subframe_ind(timer_frame, timer_subframe);

      //start_meas(&UE->timer_stats);
      //oai_subframe_ind(proc->frame_tx, proc->subframe_tx);



      //oai_subframe_ind(timer_frame, timer_subframe);


      if(UE_mac_inst[Mod_id].dl_config_req!= NULL) {
	//LOG_I( MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 after oai_subframe_ind 3, NB_UE_INST:%d \n", NB_UE_INST);
	dl_config_req_UE_MAC(UE_mac_inst[Mod_id].dl_config_req, Mod_id);
      }
      //if(UE_mac_inst[Mod_id].hi_dci0_req!= NULL){
      if (UE_mac_inst[Mod_id].hi_dci0_req!=NULL && UE_mac_inst[Mod_id].hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list!=NULL){
1039
    	  //LOG_I( MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 after oai_subframe_ind 4 \n");
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
    	  hi_dci0_req_UE_MAC(UE_mac_inst[Mod_id].hi_dci0_req, Mod_id);
    	  //if(UE_mac_inst[Mod_id].hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list!=NULL){
    		  free(UE_mac_inst[Mod_id].hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list);
    		  UE_mac_inst[Mod_id].hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list = NULL;
    	  //}
    	  free(UE_mac_inst[Mod_id].hi_dci0_req);
    	  UE_mac_inst[Mod_id].hi_dci0_req = NULL;
      }

      else if(UE_mac_inst[Mod_id].hi_dci0_req!=NULL){
      		free(UE_mac_inst[Mod_id].hi_dci0_req);
      		UE_mac_inst[Mod_id].hi_dci0_req = NULL;
      	}
      //stop_meas(&UE->timer_stats);
      //t_diff = get_time_meas_us(&UE->timer_stats);
      //LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);

      if(nfapi_mode!=3)
      phy_procedures_UE_SL_TX(UE,proc);

      //#endif
    }

#if UE_TIMING_TRACE
    start_meas(&UE->generic_stat);
#endif

    if (UE->mac_enabled==1) {

      ret = ue_scheduler(UE->Mod_id,
			 proc->frame_rx,
			 proc->subframe_rx,
			 proc->frame_tx,
			 proc->subframe_tx,
			 subframe_select(&UE->frame_parms,proc->subframe_tx),
			 0,
			 0/*FIXME CC_id*/);
      if ( ret != CONNECTION_OK) {
	char *txt;
	switch (ret) {
	case CONNECTION_LOST:
	  txt="RRC Connection lost, returning to PRACH";
	  break;
	case PHY_RESYNCH:
	  txt="RRC Connection lost, trying to resynch";
	  break;
	case RESYNCH:
	  txt="return to PRACH and perform a contention-free access";
	  break;
	default:
	  txt="UNKNOWN RETURN CODE";
	};
	LOG_E( PHY, "[UE %"PRIu8"] Frame %"PRIu32", subframe %u %s\n",
	       UE->Mod_id, proc->frame_rx, proc->subframe_tx,txt );
      }
    }
#if UE_TIMING_TRACE
    stop_meas(&UE->generic_stat);
#endif


    // Prepare the future Tx data

    if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_UL) ||
	(UE->frame_parms.frame_type == FDD) )
      if (UE->mode != loop_through_memory){

1107 1108 1109
    // We make the start of RA between consecutive UEs differ by 20 frames
	//if ((UE_mac_inst[Mod_id].UE_mode[0] == PRACH  && Mod_id == 0) || (UE_mac_inst[Mod_id].UE_mode[0] == PRACH && Mod_id>0 && proc->frame_rx >= UE_mac_inst[Mod_id-1].ra_frame + 20) ) {
	if (UE_mac_inst[Mod_id].UE_mode[0] == PRACH  && Mod_id == next_Mod_id && proc->frame_rx >= next_ra_frame) {
1110 1111 1112 1113
	  //LOG_D(MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 before RACH \n");

	  // check if we have PRACH opportunity

1114
	  if (is_prach_subframe(&UE->frame_parms,proc->frame_tx, proc->subframe_tx) &&  UE_mac_inst[Mod_id].SI_Decoded == 1) {
1115 1116 1117 1118

	  // The one working strangely...
      //if (is_prach_subframe(&UE->frame_parms,proc->frame_tx, proc->subframe_tx && Mod_id == (module_id_t) init_ra_UE) ) {

1119 1120 1121
	    //LOG_I(MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 before RACH 2 \n");
	    PRACH_RESOURCES_t *prach_resources = ue_get_rach(Mod_id, 0, proc->frame_tx, 0, proc->subframe_tx);
	    if(prach_resources!=NULL ) {
1122 1123
	    	UE_mac_inst[Mod_id].ra_frame = proc->frame_rx;
	      LOG_I(MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 before RACH 3, Mod_id: %d \n", Mod_id );
1124 1125 1126
	      fill_rach_indication_UE_MAC(Mod_id, proc->frame_tx ,proc->subframe_tx, UL_INFO, prach_resources->ra_PreambleIndex, prach_resources->ra_RNTI);
	      Msg1_transmitted(Mod_id, 0, proc->frame_tx, 0);
	      UE_mac_inst[Mod_id].UE_mode[0] = RA_RESPONSE;
1127 1128
	      next_Mod_id = Mod_id + 1;
	      next_ra_frame = (proc->frame_rx + 20)%1000;
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 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
	    }

	    //ue_prach_procedures(ue,proc,eNB_id,abstraction_flag,mode);
	  }
	} // mode is PRACH
	// Panos: Substitute call to phy_procedures Tx with call to phy_stub functions in order to trigger
	// UE Tx procedures directly at the MAC layer, based on the received ul_config requests from the vnf (eNB).
	// Generate UL_indications which correspond to UL traffic.
	if(UE_mac_inst[Mod_id].ul_config_req!= NULL){ //&& UE_mac_inst[Mod_id].ul_config_req->ul_config_request_body.ul_config_pdu_list != NULL){
		//LOG_I(MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 ul_config_req is not NULL \n");
		ul_config_req_UE_MAC(UE_mac_inst[Mod_id].ul_config_req, timer_frame, timer_subframe, Mod_id);
		//ul_config_req_UE_MAC(UE_mac_inst[Mod_id].ul_config_req, proc->frame_tx, proc->subframe_tx);
		if(UE_mac_inst[Mod_id].ul_config_req->ul_config_request_body.ul_config_pdu_list != NULL){
			free(UE_mac_inst[Mod_id].ul_config_req->ul_config_request_body.ul_config_pdu_list);
			UE_mac_inst[Mod_id].ul_config_req->ul_config_request_body.ul_config_pdu_list = NULL;
		}
		free(UE_mac_inst[Mod_id].ul_config_req);
		UE_mac_inst[Mod_id].ul_config_req = NULL;
		//UL_indication(UL_INFO);
	}
	else if(UE_mac_inst[Mod_id].ul_config_req!=NULL){
		free(UE_mac_inst[Mod_id].ul_config_req);
		UE_mac_inst[Mod_id].ul_config_req = NULL;
	}
      }

    phy_procedures_UE_SL_RX(UE,proc);


    /*if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_S) &&
      (UE->frame_parms.frame_type == TDD))
      if (UE->mode != loop_through_memory)
      phy_procedures_UE_S_TX(UE,0,0,no_relay);
      updateTimes(current, &t3, 10000, "Delay to process sub-frame (case 3)");*/

    //if (pthread_mutex_lock(&proc->mutex_rxtx) != 0) {
    /*if (pthread_mutex_lock(&phy_stub_ticking->mutex_ticking) != 0) {
      LOG_E( PHY, "[SCHED][UE] error locking mutex for UE RXTX\n" );
      exit_fun("noting to add");
    }

    //proc->instance_cnt_rxtx--;

    //if (pthread_mutex_unlock(&proc->mutex_rxtx) != 0) {
    if (pthread_mutex_unlock(&phy_stub_ticking->mutex_ticking) != 0) {
      LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE RXTX\n" );
      exit_fun("noting to add");
    }*/
    } //for (Mod_id=0; Mod_id<NB_UE_INST; Mod_id++)

    if(tx_request_pdu_list!=NULL){
    	  free(tx_request_pdu_list);
      	  tx_request_pdu_list = NULL;
      }
1183 1184 1185 1186 1187


    if (UL_INFO->crc_ind.crc_indication_body.number_of_crcs>0)
      {
    	  //LOG_D(PHY,"UL_info->crc_ind.crc_indication_body.number_of_crcs:%d CRC_IND:SFN/SF:%d\n", UL_info->crc_ind.crc_indication_body.number_of_crcs, NFAPI_SFNSF2DEC(UL_info->crc_ind.sfn_sf));
1188
    	  //LOG_I(MAC, "Panos-D: ul_config_req_UE_MAC 2.2, SFN/SF of PNF counter:%d.%d, number_of_crcs: %d \n", timer_frame, timer_subframe, UL_INFO->crc_ind.crc_indication_body.number_of_crcs);
1189 1190 1191 1192 1193 1194 1195
    	  oai_nfapi_crc_indication(&UL_INFO->crc_ind);
    	  //LOG_I(MAC, "Panos-D: ul_config_req_UE_MAC 2.21 \n");
    	  UL_INFO->crc_ind.crc_indication_body.number_of_crcs = 0;
      }
      if (UL_INFO->rx_ind.rx_indication_body.number_of_pdus>0)
      {
    	  //LOG_D(PHY,"UL_info->rx_ind.number_of_pdus:%d RX_IND:SFN/SF:%d\n", UL_info->rx_ind.rx_indication_body.number_of_pdus, NFAPI_SFNSF2DEC(UL_info->rx_ind.sfn_sf));
1196
    	  //LOG_I(MAC, "Panos-D: ul_config_req_UE_MAC 2.3, SFN/SF of PNF counter:%d.%d, number_of_pdus: %d \n", timer_frame, timer_subframe, UL_INFO->rx_ind.rx_indication_body.number_of_pdus);
1197 1198 1199 1200 1201 1202 1203
    	  //LOG_I(MAC, "Panos-D: ul_config_req_UE_MAC 2.3 \n");
    	  oai_nfapi_rx_ind(&UL_INFO->rx_ind);
    	  //LOG_I(MAC, "Panos-D: ul_config_req_UE_MAC 2.31 \n");
    	  UL_INFO->rx_ind.rx_indication_body.number_of_pdus = 0;
      }
      if(UL_INFO->harq_ind.harq_indication_body.number_of_harqs>0)
      {
1204
    	  //LOG_D(MAC, "Panos-D: ul_config_req_UE_MAC 2.4, SFN/SF of PNF counter:%d.%d, number_of_harqs: %d \n", timer_frame, timer_subframe, UL_INFO->harq_ind.harq_indication_body.number_of_harqs);
1205 1206 1207 1208 1209 1210 1211
    	  oai_nfapi_harq_indication(&UL_INFO->harq_ind);
    	  //LOG_I(MAC, "Panos-D: ul_config_req_UE_MAC 2.41 \n");
    	  UL_INFO->harq_ind.harq_indication_body.number_of_harqs =0;

      }
      if(UL_INFO->sr_ind.sr_indication_body.number_of_srs>0)
      {
1212
    	  //LOG_I(MAC, "Panos-D: ul_config_req_UE_MAC 2.5, SFN/SF of PNF counter:%d.%d, number_of_srs: %d \n", timer_frame, timer_subframe, UL_INFO->sr_ind.sr_indication_body.number_of_srs);
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
    	  oai_nfapi_sr_indication(&UL_INFO->sr_ind);
    	  //LOG_I(MAC, "Panos-D: ul_config_req_UE_MAC 2.51 \n");
    	  UL_INFO->sr_ind.sr_indication_body.number_of_srs = 0;
      }

      // Free UL_INFO messages
      //if(UL_INFO->crc_ind.crc_indication_body.crc_pdu_list != NULL){
    	  free(UL_INFO->crc_ind.crc_indication_body.crc_pdu_list);
    	  UL_INFO->crc_ind.crc_indication_body.crc_pdu_list = NULL;
      //}
      //if(UL_INFO->rx_ind.rx_indication_body.rx_pdu_list != NULL){
    	  free(UL_INFO->rx_ind.rx_indication_body.rx_pdu_list);
    	  UL_INFO->rx_ind.rx_indication_body.rx_pdu_list = NULL;
      //}
      //if(UL_INFO->harq_ind.harq_indication_body.harq_pdu_list !=NULL){
    	  free(UL_INFO->harq_ind.harq_indication_body.harq_pdu_list);
    	  UL_INFO->harq_ind.harq_indication_body.harq_pdu_list = NULL;
      //}
      //if(UL_INFO->sr_ind.sr_indication_body.sr_pdu_list!=NULL){
    	  free(UL_INFO->sr_ind.sr_indication_body.sr_pdu_list);
    	  UL_INFO->sr_ind.sr_indication_body.sr_pdu_list = NULL;
      //}

      free(UL_INFO);
      UL_INFO = NULL;







1245 1246 1247 1248 1249 1250 1251 1252 1253
  }
  // thread finished
  free(arg);
  return &UE_thread_rxtx_retval;
}




1254 1255 1256 1257 1258 1259 1260 1261 1262
/*!
 * \brief This is the UE thread for RX subframe n and TX subframe n+4.
 * This thread performs the phy_procedures_UE_RX() on every received slot.
 * then, if TX is enabled it performs TX for n+4.
 * \param arg is a pointer to a \ref PHY_VARS_UE structure.
 * \returns a pointer to an int. The storage is not on the heap and must not be freed.
 */

static void *UE_phy_stub_thread_rxn_txnp4(void *arg) {
matzakos's avatar
matzakos committed
1263

1264 1265 1266
	thread_top_init("UE_phy_stub_thread_rxn_txnp4",1,870000L,1000000L,1000000L);

	module_id_t Mod_id = 0;
1267 1268 1269 1270 1271
  static __thread int UE_thread_rxtx_retval;
  struct rx_tx_thread_data *rtd = arg;
  UE_rxtx_proc_t *proc = rtd->proc;
  PHY_VARS_UE    *UE   = rtd->UE;
  int ret;
1272
  //  double t_diff;
1273

1274 1275
  char threadname[256];
  sprintf(threadname,"UE_%d_proc", UE->Mod_id);
1276

1277 1278 1279
  // Panos: Call (Sched_Rsp_t) get_nfapi_sched_response(UE->Mod_ID) to get all
  //sched_response config messages which concern the specific UE. Inside this
  //function we should somehow make the translation of rnti to Mod_ID.
1280

1281
  //proc->instance_cnt_rxtx=-1;
1282

1283 1284
  phy_stub_ticking->ticking_var = -1;
  proc->subframe_rx=proc->sub_frame_start;
1285

1286 1287 1288
  //PANOS: CAREFUL HERE!
  wait_sync("UE_phy_stub_thread_rxn_txnp4");

1289
  while (!oai_exit) {
1290

1291
    if (pthread_mutex_lock(&phy_stub_ticking->mutex_ticking) != 0) {
1292
      LOG_E( MAC, "[SCHED][UE] error locking mutex for UE RXTX\n" );
1293 1294 1295 1296
      exit_fun("nothing to add");
    }
    while (phy_stub_ticking->ticking_var < 0) {
      // most of the time, the thread is waiting here
1297
      //pthread_cond_wait( &proc->cond_rxtx, &proc->mutex_rxtx )
1298
      LOG_D(MAC,"Waiting for ticking_var\n");
1299 1300
      pthread_cond_wait( &phy_stub_ticking->cond_ticking, &phy_stub_ticking->mutex_ticking);
    }
1301
    phy_stub_ticking->ticking_var--;
1302
    if (pthread_mutex_unlock(&phy_stub_ticking->mutex_ticking) != 0) {
1303
      LOG_E( MAC, "[SCHED][UE] error unlocking mutex for UE RXn_TXnp4\n" );
1304 1305
      exit_fun("nothing to add");
    }
1306 1307
    LOG_D(MAC," Panos-D [UE_phy_stub_thread_rxn_txnp4 1] Frame: %d, Subframe: %d \n" "\n" "\n", timer_frame, timer_subframe);

1308 1309 1310

    proc->subframe_rx=timer_subframe;
    proc->frame_rx = timer_frame;
1311 1312
    proc->subframe_tx=(timer_subframe+4)%10;
    proc->frame_tx = proc->frame_rx + (proc->subframe_rx>5?1:0);
1313 1314
    //oai_subframe_ind(proc->frame_rx, proc->subframe_rx);

1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346


    // Panos: Guessing that the next 4 lines are not needed for the phy_stub mode.
    /*initRefTimes(t2);
      initRefTimes(t3);
      pickTime(current);
      updateTimes(proc->gotIQs, &t2, 10000, "Delay to wake up UE_Thread_Rx (case 2)");*/


    // Process Rx data for one sub-frame
    lte_subframe_t sf_type = subframe_select( &UE->frame_parms, proc->subframe_rx);
    if ((sf_type == SF_DL) ||
	(UE->frame_parms.frame_type == FDD) ||
	(sf_type == SF_S)) {

      if (UE->frame_parms.frame_type == TDD) {
	LOG_D(PHY, "%s,TDD%d,%s: calling UE_RX\n",
	      threadname,
	      UE->frame_parms.tdd_config,
	      (sf_type==SF_DL? "SF_DL" :
	       (sf_type==SF_UL? "SF_UL" :
		(sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
      } else {
	LOG_D(PHY, "%s,%s,%s: calling UE_RX\n",
	      threadname,
	      (UE->frame_parms.frame_type==FDD? "FDD":
	       (UE->frame_parms.frame_type==TDD? "TDD":"UNKNOWN_DUPLEX_MODE")),
	      (sf_type==SF_DL? "SF_DL" :
	       (sf_type==SF_UL? "SF_UL" :
		(sf_type==SF_S ? "SF_S"  : "UNKNOWN_SF_TYPE"))));
      }

1347

1348
      phy_procedures_UE_SL_RX(UE,proc);
1349

1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
      /*
	#ifdef UE_SLOT_PARALLELISATION
	phy_procedures_slot_parallelization_UE_RX( UE, proc, 0, 0, 1, UE->mode, no_relay, NULL );
	#else
      */
      // Panos: Substitute call to phy_procedures Rx with call to phy_stub functions in order to trigger
      // UE Rx procedures directly at the MAC layer, based on the received nfapi requests from the vnf (eNB).
      // Hardcode Mod_id for now. Will be changed later.

      // Panos: is this the right place to call oai_subframe_indication to invoke p7 nfapi callbacks here?
1360 1361 1362 1363 1364 1365 1366 1367

      //oai_subframe_ind(proc->frame_rx, proc->subframe_rx);
      //oai_subframe_ind(timer_frame, timer_subframe);

      //start_meas(&UE->timer_stats);
      //oai_subframe_ind(proc->frame_tx, proc->subframe_tx);
      oai_subframe_ind(timer_frame, timer_subframe);
      //LOG_I( MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 after oai_subframe_ind \n");
1368 1369 1370 1371 1372 1373
      //printf("Panos-D: UE_phy_stub_thread_rxn_txnp4 after oai_subframe_ind \n");
      /*if(UE_mac_inst[Mod_id].tx_req!= NULL){
	printf("Panos-D: UE_phy_stub_thread_rxn_txnp4 after oai_subframe_ind 2\n");
	tx_req_UE_MAC(UE_mac_inst[Mod_id].tx_req);
	}*/
      if(UE_mac_inst[Mod_id].dl_config_req!= NULL) {
1374
	//LOG_I( MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 after oai_subframe_ind 3 \n");
1375 1376
	dl_config_req_UE_MAC(UE_mac_inst[Mod_id].dl_config_req, Mod_id);
      //dl_config_req_UE_MAC(UE_mac_inst[Mod_id].dl_config_req, UE_mac_inst[Mod_id].tx_request_pdu_list);
1377
      }
1378 1379 1380
      //if(UE_mac_inst[Mod_id].hi_dci0_req!= NULL){
      if (UE_mac_inst[Mod_id].hi_dci0_req!=NULL && UE_mac_inst[Mod_id].hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list!=NULL){
    	  LOG_I( MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 after oai_subframe_ind 4 \n");
1381
    	  hi_dci0_req_UE_MAC(UE_mac_inst[Mod_id].hi_dci0_req, Mod_id);
1382 1383 1384 1385 1386 1387
    	  //if(UE_mac_inst[Mod_id].hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list!=NULL){
    		  free(UE_mac_inst[Mod_id].hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list);
    		  UE_mac_inst[Mod_id].hi_dci0_req->hi_dci0_request_body.hi_dci0_pdu_list = NULL;
    	  //}
    	  free(UE_mac_inst[Mod_id].hi_dci0_req);
    	  UE_mac_inst[Mod_id].hi_dci0_req = NULL;
1388
      }
1389 1390 1391 1392 1393

      else if(UE_mac_inst[Mod_id].hi_dci0_req!=NULL){
      		free(UE_mac_inst[Mod_id].hi_dci0_req);
      		UE_mac_inst[Mod_id].hi_dci0_req = NULL;
      	}
1394 1395 1396
      //stop_meas(&UE->timer_stats);
      //t_diff = get_time_meas_us(&UE->timer_stats);
      //LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);
1397

1398
      if (nfapi_mode != 3)
1399
        phy_procedures_UE_SL_TX(UE,proc);
1400

1401 1402
      //#endif
    }
hbilel's avatar
hbilel committed
1403

gabrielC's avatar
gabrielC committed
1404
#if UE_TIMING_TRACE
1405
    start_meas(&UE->generic_stat);
gabrielC's avatar
gabrielC committed
1406
#endif
1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435
    if (UE->mac_enabled==1) {

      ret = ue_scheduler(UE->Mod_id,
			 proc->frame_rx,
			 proc->subframe_rx,
			 proc->frame_tx,
			 proc->subframe_tx,
			 subframe_select(&UE->frame_parms,proc->subframe_tx),
			 0,
			 0/*FIXME CC_id*/);
      if ( ret != CONNECTION_OK) {
	char *txt;
	switch (ret) {
	case CONNECTION_LOST:
	  txt="RRC Connection lost, returning to PRACH";
	  break;
	case PHY_RESYNCH:
	  txt="RRC Connection lost, trying to resynch";
	  break;
	case RESYNCH:
	  txt="return to PRACH and perform a contention-free access";
	  break;
	default:
	  txt="UNKNOWN RETURN CODE";
	};
	LOG_E( PHY, "[UE %"PRIu8"] Frame %"PRIu32", subframe %u %s\n",
	       UE->Mod_id, proc->frame_rx, proc->subframe_tx,txt );
      }
    }
gabrielC's avatar
gabrielC committed
1436
#if UE_TIMING_TRACE
1437
    stop_meas(&UE->generic_stat);
gabrielC's avatar
gabrielC committed
1438
#endif
hbilel's avatar
hbilel committed
1439

1440

1441
    // Prepare the future Tx data
1442

1443 1444 1445 1446 1447
    if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_UL) ||
	(UE->frame_parms.frame_type == FDD) )
      if (UE->mode != loop_through_memory){

	if ((UE_mac_inst[Mod_id].UE_mode[0] == PRACH) ) {
1448
	  //LOG_D(MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 before RACH \n");
1449 1450 1451 1452

	  // check if we have PRACH opportunity

	  if (is_prach_subframe(&UE->frame_parms,proc->frame_tx, proc->subframe_tx)) {
1453
	    //LOG_I(MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 before RACH 2 \n");
1454 1455
	    PRACH_RESOURCES_t *prach_resources = ue_get_rach(Mod_id, 0, proc->frame_tx, 0, proc->subframe_tx);
	    if(prach_resources!=NULL) {
1456
	      //LOG_I(MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 before RACH 3 \n");
1457 1458 1459 1460
	      fill_rach_indication_UE_MAC(Mod_id, proc->frame_tx ,proc->subframe_tx, UL_INFO, prach_resources->ra_PreambleIndex, prach_resources->ra_RNTI);
	      Msg1_transmitted(Mod_id, 0, proc->frame_tx, 0);
	      UE_mac_inst[Mod_id].UE_mode[0] = RA_RESPONSE;
	    }
1461

1462 1463 1464 1465 1466
	    //ue_prach_procedures(ue,proc,eNB_id,abstraction_flag,mode);
	  }
	} // mode is PRACH
	// Panos: Substitute call to phy_procedures Tx with call to phy_stub functions in order to trigger
	// UE Tx procedures directly at the MAC layer, based on the received ul_config requests from the vnf (eNB).
1467 1468
	// Generate UL_indications which correspond to UL traffic.
	if(UE_mac_inst[Mod_id].ul_config_req!= NULL && UE_mac_inst[Mod_id].ul_config_req->ul_config_request_body.ul_config_pdu_list != NULL){
1469
		//LOG_I(MAC, "Panos-D: UE_phy_stub_thread_rxn_txnp4 ul_config_req is not NULL \n");
1470
		ul_config_req_UE_MAC(UE_mac_inst[Mod_id].ul_config_req, timer_frame, timer_subframe, Mod_id);
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
		//ul_config_req_UE_MAC(UE_mac_inst[Mod_id].ul_config_req, proc->frame_tx, proc->subframe_tx);
		if(UE_mac_inst[Mod_id].ul_config_req->ul_config_request_body.ul_config_pdu_list != NULL){
			free(UE_mac_inst[Mod_id].ul_config_req->ul_config_request_body.ul_config_pdu_list);
			UE_mac_inst[Mod_id].ul_config_req->ul_config_request_body.ul_config_pdu_list = NULL;
		}
		free(UE_mac_inst[Mod_id].ul_config_req);
		UE_mac_inst[Mod_id].ul_config_req = NULL;
		//UL_indication(UL_INFO);
	}
	else if(UE_mac_inst[Mod_id].ul_config_req!=NULL){
		free(UE_mac_inst[Mod_id].ul_config_req);
		UE_mac_inst[Mod_id].ul_config_req = NULL;
1483 1484
	}
      }
1485

1486
    phy_procedures_UE_SL_RX(UE,proc);
1487

1488

1489 1490 1491 1492 1493
    /*if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_S) &&
      (UE->frame_parms.frame_type == TDD))
      if (UE->mode != loop_through_memory)
      phy_procedures_UE_S_TX(UE,0,0,no_relay);
      updateTimes(current, &t3, 10000, "Delay to process sub-frame (case 3)");*/
1494

1495
    //if (pthread_mutex_lock(&proc->mutex_rxtx) != 0) {
1496
    /*if (pthread_mutex_lock(&phy_stub_ticking->mutex_ticking) != 0) {
1497 1498 1499
      LOG_E( PHY, "[SCHED][UE] error locking mutex for UE RXTX\n" );
      exit_fun("noting to add");
    }
1500

1501
    //proc->instance_cnt_rxtx--;
1502

1503 1504 1505 1506
    //if (pthread_mutex_unlock(&proc->mutex_rxtx) != 0) {
    if (pthread_mutex_unlock(&phy_stub_ticking->mutex_ticking) != 0) {
      LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE RXTX\n" );
      exit_fun("noting to add");
1507
    }*/
1508 1509 1510 1511
  }
  // thread finished
  free(arg);
  return &UE_thread_rxtx_retval;
Florian Kaltenberger's avatar
 
Florian Kaltenberger committed
1512
}
1513

1514 1515


1516 1517 1518
/*!
 * \brief This is the main UE thread.
 * This thread controls the other three UE threads:
1519 1520
 * - UE_thread_rxn_txnp4 (even subframes)
 * - UE_thread_rxn_txnp4 (odd subframes)
1521 1522 1523 1524
 * - UE_thread_synch
 * \param arg unused
 * \returns a pointer to an int. The storage is not on the heap and must not be freed.
 */
1525

1526 1527 1528
void *UE_thread(void *arg) {


1529 1530 1531 1532 1533 1534 1535 1536
  PHY_VARS_UE *UE = (PHY_VARS_UE *) arg;
  //  int tx_enabled = 0;
  int dummy_rx[UE->frame_parms.nb_antennas_rx][UE->frame_parms.samples_per_tti] __attribute__((aligned(32)));
  openair0_timestamp timestamp,timestamp1;
  void* rxp[NB_ANTENNAS_RX], *txp[NB_ANTENNAS_TX];
  int start_rx_stream = 0;
  int i;
  int th_id;
1537

1538
  static uint8_t thread_idx = 0;
1539

1540 1541 1542 1543 1544 1545
  cpu_set_t cpuset;
  CPU_ZERO(&cpuset);
  if ( threads.iq != -1 )
    CPU_SET(threads.iq, &cpuset);
  init_thread(100000, 500000, FIFO_PRIORITY, &cpuset,
	      "UHD Threads");
1546 1547

#ifdef NAS_UE
1548 1549 1550
  MessageDef *message_p;
  message_p = itti_alloc_new_message(TASK_NAS_UE, INITIALIZE_MESSAGE);
  itti_send_msg_to_task (TASK_NAS_UE, UE->Mod_id + NB_eNB_INST, message_p);
1551
#endif
1552

1553 1554
  int sub_frame=-1;
  //int cumulated_shift=0;
1555

1556

1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
  while (!oai_exit) {
    AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
    int instance_cnt_synch = UE->proc.instance_cnt_synch;
    int is_synchronized    = UE->is_synchronized;
    AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");

    if (is_synchronized == 0) {
      if (instance_cnt_synch < 0) {  // we can invoke the synch
	// grab 10 ms of signal and wakeup synch thread
	for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
	  rxp[i] = (void*)&UE->common_vars.rxdata[i][0];

	if (UE->mode != loop_through_memory)
	  AssertFatal( UE->frame_parms.samples_per_tti*10 ==
		       UE->rfdevice.trx_read_func(&UE->rfdevice,
						  &timestamp,
						  rxp,
						  UE->frame_parms.samples_per_tti*10,
						  UE->frame_parms.nb_antennas_rx), "");
	AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
	instance_cnt_synch = ++UE->proc.instance_cnt_synch;
	if (instance_cnt_synch == 0) {
	  AssertFatal( 0 == pthread_cond_signal(&UE->proc.cond_synch), "");
	} else {
	  LOG_E( PHY, "[SCHED][UE] UE sync thread busy!!\n" );
	  exit_fun("nothing to add");
	}
	AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
      } else {
Cedric Roux's avatar
Cedric Roux committed
1586
#if OAISIM
1587 1588
	(void)dummy_rx; /* avoid gcc warnings */
	usleep(500);
Cedric Roux's avatar
Cedric Roux committed
1589
#else
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
	// grab 10 ms of signal into dummy buffer
	if (UE->mode != loop_through_memory) {
	  for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
	    rxp[i] = (void*)&dummy_rx[i][0];
	  for (int sf=0; sf<10; sf++)
	    //	    printf("Reading dummy sf %d\n",sf);
	    UE->rfdevice.trx_read_func(&UE->rfdevice,
				       &timestamp,
				       rxp,
				       UE->frame_parms.samples_per_tti,
				       UE->frame_parms.nb_antennas_rx);
	}
Cedric Roux's avatar
Cedric Roux committed
1602
#endif
1603 1604
	}

laurent's avatar
laurent committed
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
        } // UE->is_synchronized==0
        else {
            if (start_rx_stream==0) {
                start_rx_stream=1;
                if (UE->mode != loop_through_memory) {
                    if (UE->no_timing_correction==0) {
                        LOG_I(PHY,"Resynchronizing RX by %d samples (mode = %d)\n",UE->rx_offset,UE->mode);
                        AssertFatal(UE->rx_offset ==
                                    UE->rfdevice.trx_read_func(&UE->rfdevice,
                                                               &timestamp,
1615
                                                               (void**)UE->common_vars.rxdata,
laurent's avatar
laurent committed
1616 1617 1618 1619
                                                               UE->rx_offset,
                                                               UE->frame_parms.nb_antennas_rx),"");
                    }
                    UE->rx_offset=0;
1620
                    UE->time_sync_cell=0;
1621 1622 1623 1624 1625
                    //UE->proc.proc_rxtx[0].frame_rx++;
                    //UE->proc.proc_rxtx[1].frame_rx++;
                    for (th_id=0; th_id < RX_NB_TH; th_id++) {
                        UE->proc.proc_rxtx[th_id].frame_rx++;
                    }
laurent's avatar
laurent committed
1626 1627 1628 1629 1630

                    // read in first symbol
                    AssertFatal (UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0 ==
                                 UE->rfdevice.trx_read_func(&UE->rfdevice,
                                                            &timestamp,
1631 1632
                                                            (void**)UE->common_vars.rxdata,
                                                            UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0,
laurent's avatar
laurent committed
1633 1634 1635 1636 1637 1638 1639 1640 1641
                                                            UE->frame_parms.nb_antennas_rx),"");
                    slot_fep(UE,0, 0, 0, 0, 0);
                } //UE->mode != loop_through_memory
                else
                    rt_sleep_ns(1000*1000);

            } else {
                sub_frame++;
                sub_frame%=10;
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
                UE_rxtx_proc_t *proc = &UE->proc.proc_rxtx[thread_idx];
                // update thread index for received subframe
                UE->current_thread_id[sub_frame] = thread_idx;

                LOG_D(PHY,"Process Subframe %d thread Idx %d \n", sub_frame, UE->current_thread_id[sub_frame]);

                thread_idx++;
                if(thread_idx>=RX_NB_TH)
                    thread_idx = 0;

laurent's avatar
laurent committed
1652 1653 1654

                if (UE->mode != loop_through_memory) {
                    for (i=0; i<UE->frame_parms.nb_antennas_rx; i++)
Laurent's avatar
Laurent committed
1655
                        rxp[i] = (void*)&UE->common_vars.rxdata[i][UE->frame_parms.ofdm_symbol_size+
1656 1657
                                 UE->frame_parms.nb_prefix_samples0+
                                 sub_frame*UE->frame_parms.samples_per_tti];
laurent's avatar
laurent committed
1658 1659 1660 1661 1662 1663 1664 1665
                    for (i=0; i<UE->frame_parms.nb_antennas_tx; i++)
                        txp[i] = (void*)&UE->common_vars.txdata[i][((sub_frame+2)%10)*UE->frame_parms.samples_per_tti];

                    int readBlockSize, writeBlockSize;
                    if (sub_frame<9) {
                        readBlockSize=UE->frame_parms.samples_per_tti;
                        writeBlockSize=UE->frame_parms.samples_per_tti;
                    } else {
1666
                        // set TO compensation to zero
1667

1668
                        UE->rx_offset_diff = 0;
1669

1670
                        // compute TO compensation that should be applied for this frame
1671 1672 1673 1674

			if (UE->no_timing_correction == 0) {
			  if ( UE->rx_offset < 5*UE->frame_parms.samples_per_tti  &&
			       UE->rx_offset > 0 )
laurent's avatar
laurent committed
1675
                            UE->rx_offset_diff = -1 ;
1676 1677
			  if ( UE->rx_offset > 5*UE->frame_parms.samples_per_tti &&
			       UE->rx_offset < 10*UE->frame_parms.samples_per_tti )
laurent's avatar
laurent committed
1678
                            UE->rx_offset_diff = 1;
1679
			}
laurent's avatar
laurent committed
1680

1681
                        LOG_D(PHY,"AbsSubframe %d.%d SET rx_off_diff to %d rx_offset %d \n",proc->frame_rx,sub_frame,UE->rx_offset_diff,UE->rx_offset);
laurent's avatar
laurent committed
1682 1683 1684 1685 1686 1687
                        readBlockSize=UE->frame_parms.samples_per_tti -
                                      UE->frame_parms.ofdm_symbol_size -
                                      UE->frame_parms.nb_prefix_samples0 -
                                      UE->rx_offset_diff;
                        writeBlockSize=UE->frame_parms.samples_per_tti -
                                       UE->rx_offset_diff;
laurent's avatar
laurent committed
1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
                    }

                    AssertFatal(readBlockSize ==
                                UE->rfdevice.trx_read_func(&UE->rfdevice,
                                                           &timestamp,
                                                           rxp,
                                                           readBlockSize,
                                                           UE->frame_parms.nb_antennas_rx),"");
                    AssertFatal( writeBlockSize ==
                                 UE->rfdevice.trx_write_func(&UE->rfdevice,
                                         timestamp+
                                         (2*UE->frame_parms.samples_per_tti) -
                                         UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0 -
                                         openair0_cfg[0].tx_sample_advance,
                                         txp,
                                         writeBlockSize,
                                         UE->frame_parms.nb_antennas_tx,
                                         1),"");
                    if( sub_frame==9) {
                        // read in first symbol of next frame and adjust for timing drift
                        int first_symbols=writeBlockSize-readBlockSize;
                        if ( first_symbols > 0 )
                            AssertFatal(first_symbols ==
                                        UE->rfdevice.trx_read_func(&UE->rfdevice,
                                                                   &timestamp1,
Laurent's avatar
Laurent committed
1713
                                                                   (void**)UE->common_vars.rxdata,
laurent's avatar
laurent committed
1714 1715 1716 1717 1718
                                                                   first_symbols,
                                                                   UE->frame_parms.nb_antennas_rx),"");
                        if ( first_symbols <0 )
                            LOG_E(PHY,"can't compensate: diff =%d\n", first_symbols);
                    }
laurent's avatar
laurent committed
1719
                    pickTime(gotIQs);
laurent's avatar
laurent committed
1720 1721 1722
                    // operate on thread sf mod 2
                    AssertFatal(pthread_mutex_lock(&proc->mutex_rxtx) ==0,"");
                    if(sub_frame == 0) {
1723 1724 1725 1726 1727 1728 1729 1730 1731 1732
                        //UE->proc.proc_rxtx[0].frame_rx++;
                        //UE->proc.proc_rxtx[1].frame_rx++;
                        for (th_id=0; th_id < RX_NB_TH; th_id++) {
                            UE->proc.proc_rxtx[th_id].frame_rx++;
                        }
                    }
                    //UE->proc.proc_rxtx[0].gotIQs=readTime(gotIQs);
                    //UE->proc.proc_rxtx[1].gotIQs=readTime(gotIQs);
                    for (th_id=0; th_id < RX_NB_TH; th_id++) {
                        UE->proc.proc_rxtx[th_id].gotIQs=readTime(gotIQs);
laurent's avatar
laurent committed
1733 1734 1735 1736 1737 1738 1739 1740
                    }
                    proc->subframe_rx=sub_frame;
                    proc->subframe_tx=(sub_frame+4)%10;
                    proc->frame_tx = proc->frame_rx + (proc->subframe_rx>5?1:0);
                    proc->timestamp_tx = timestamp+
                                         (4*UE->frame_parms.samples_per_tti)-
                                         UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0;

1741
                    proc->instance_cnt_rxtx++;
1742
                    LOG_D( PHY, "[SCHED][UE %d] UE RX instance_cnt_rxtx %d subframe %d !!\n", UE->Mod_id, proc->instance_cnt_rxtx,proc->subframe_rx);
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753
                    if (proc->instance_cnt_rxtx == 0) {
                      if (pthread_cond_signal(&proc->cond_rxtx) != 0) {
                        LOG_E( PHY, "[SCHED][UE %d] ERROR pthread_cond_signal for UE RX thread\n", UE->Mod_id);
                        exit_fun("nothing to add");
                      }
                    } else {
                      LOG_E( PHY, "[SCHED][UE %d] UE RX thread busy (IC %d)!!\n", UE->Mod_id, proc->instance_cnt_rxtx);
                      if (proc->instance_cnt_rxtx > 2)
                        exit_fun("instance_cnt_rxtx > 2");
                    }

laurent's avatar
laurent committed
1754 1755
                    AssertFatal (pthread_cond_signal(&proc->cond_rxtx) ==0 ,"");
                    AssertFatal(pthread_mutex_unlock(&proc->mutex_rxtx) ==0,"");
laurent's avatar
laurent committed
1756 1757 1758 1759
                    initRefTimes(t1);
                    initStaticTime(lastTime);
                    updateTimes(lastTime, &t1, 20000, "Delay between two IQ acquisitions (case 1)");
                    pickStaticTime(lastTime);
laurent's avatar
laurent committed
1760 1761 1762 1763 1764 1765 1766 1767 1768 1769

                } else {
                    printf("Processing subframe %d",proc->subframe_rx);
                    getchar();
                }
            } // start_rx_stream==1
        } // UE->is_synchronized==1

    } // while !oai_exit
    return NULL;
1770 1771
}

1772

1773 1774 1775
/*!
 * \brief Initialize the UE theads.
 * Creates the UE threads:
1776 1777
 * - UE_thread_rxtx0
 * - UE_thread_rxtx1
1778
 * - UE_thread_synch
1779 1780 1781 1782
 * - UE_thread_fep_slot0
 * - UE_thread_fep_slot1
 * - UE_thread_dlsch_proc_slot0
 * - UE_thread_dlsch_proc_slot1
1783 1784
 * and the locking between them.
 */
1785
void init_UE_threads(int inst) {
1786 1787
  struct rx_tx_thread_data *rtd;
  PHY_VARS_UE *UE;
1788

1789 1790 1791 1792
  AssertFatal(PHY_vars_UE_g!=NULL,"PHY_vars_UE_g is NULL\n");
  AssertFatal(PHY_vars_UE_g[inst]!=NULL,"PHY_vars_UE_g[inst] is NULL\n");
  AssertFatal(PHY_vars_UE_g[inst][0]!=NULL,"PHY_vars_UE_g[inst][0] is NULL\n");
  UE = PHY_vars_UE_g[inst][0];
1793

1794 1795
  pthread_attr_init (&UE->proc.attr_ue);
  pthread_attr_setstacksize(&UE->proc.attr_ue,8192);//5*PTHREAD_STACK_MIN);
1796

1797 1798
  pthread_mutex_init(&UE->proc.mutex_synch,NULL);
  pthread_cond_init(&UE->proc.cond_synch,NULL);
1799

1800 1801 1802 1803 1804 1805 1806
  // the threads are not yet active, therefore access is allowed without locking
  int nb_threads=RX_NB_TH;
  for (int i=0; i<nb_threads; i++) {
    rtd = calloc(1, sizeof(struct rx_tx_thread_data));
    if (rtd == NULL) abort();
    rtd->UE = UE;
    rtd->proc = &UE->proc.proc_rxtx[i];
1807

1808 1809 1810 1811 1812 1813
    pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_rxtx,NULL);
    pthread_cond_init(&UE->proc.proc_rxtx[i].cond_rxtx,NULL);
    UE->proc.proc_rxtx[i].sub_frame_start=i;
    UE->proc.proc_rxtx[i].sub_frame_step=nb_threads;
    printf("Init_UE_threads rtd %d proc %d nb_threads %d i %d\n",rtd->proc->sub_frame_start, UE->proc.proc_rxtx[i].sub_frame_start,nb_threads, i);
    pthread_create(&UE->proc.proc_rxtx[i].pthread_rxtx, NULL, UE_thread_rxn_txnp4, rtd);
1814

fnabet's avatar
fnabet committed
1815
#ifdef UE_SLOT_PARALLELISATION
1816 1817 1818
    //pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_slot0_dl_processing,NULL);
    //pthread_cond_init(&UE->proc.proc_rxtx[i].cond_slot0_dl_processing,NULL);
    //pthread_create(&UE->proc.proc_rxtx[i].pthread_slot0_dl_processing,NULL,UE_thread_slot0_dl_processing, rtd);
1819

1820 1821 1822
    pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_slot1_dl_processing,NULL);
    pthread_cond_init(&UE->proc.proc_rxtx[i].cond_slot1_dl_processing,NULL);
    pthread_create(&UE->proc.proc_rxtx[i].pthread_slot1_dl_processing,NULL,UE_thread_slot1_dl_processing, rtd);
fnabet's avatar
fnabet committed
1823 1824
#endif

1825 1826
  }
  pthread_create(&UE->proc.pthread_synch,NULL,UE_thread_synch,(void*)UE);
1827 1828 1829
}


1830

1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
/*!
 * \brief Initialize the UE theads.
 * Creates the UE threads:
 * - UE_thread_rxtx0
 * - UE_thread_synch
 * - UE_thread_fep_slot0
 * - UE_thread_fep_slot1
 * - UE_thread_dlsch_proc_slot0
 * - UE_thread_dlsch_proc_slot1
 * and the locking between them.
 */
void init_UE_single_thread_stub(int nb_inst) {
  struct rx_tx_thread_data *rtd;
  PHY_VARS_UE *UE;

  for (int i=0; i<nb_inst; i++){
	  AssertFatal(PHY_vars_UE_g!=NULL,"PHY_vars_UE_g is NULL\n");
	  AssertFatal(PHY_vars_UE_g[i]!=NULL,"PHY_vars_UE_g[inst] is NULL\n");
	  AssertFatal(PHY_vars_UE_g[i][0]!=NULL,"PHY_vars_UE_g[inst][0] is NULL\n");
  }
  UE = PHY_vars_UE_g[0][0];

  pthread_attr_init (&UE->proc.attr_ue);
  pthread_attr_setstacksize(&UE->proc.attr_ue,8192);//5*PTHREAD_STACK_MIN);

  // Panos: Don't need synch for phy_stub mode
  //pthread_mutex_init(&UE->proc.mutex_synch,NULL);
  //pthread_cond_init(&UE->proc.cond_synch,NULL);

  // the threads are not yet active, therefore access is allowed without locking
  // Panos: In phy_stub_UE mode due to less heavy processing operations we don't need two threads
  //int nb_threads=RX_NB_TH;
  int nb_threads=1;
  for (int i=0; i<nb_threads; i++) {
    rtd = calloc(1, sizeof(struct rx_tx_thread_data));
    if (rtd == NULL) abort();
    rtd->UE = UE;
    rtd->proc = &UE->proc.proc_rxtx[i];

    pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_rxtx,NULL);
    pthread_cond_init(&UE->proc.proc_rxtx[i].cond_rxtx,NULL);
    UE->proc.proc_rxtx[i].sub_frame_start=i;
    UE->proc.proc_rxtx[i].sub_frame_step=nb_threads;
    printf("Init_UE_threads rtd %d proc %d nb_threads %d i %d\n",rtd->proc->sub_frame_start, UE->proc.proc_rxtx[i].sub_frame_start,nb_threads, i);
    pthread_create(&UE->proc.proc_rxtx[i].pthread_rxtx, NULL, UE_phy_stub_single_thread_rxn_txnp4, rtd);
    /*
      #ifdef UE_SLOT_PARALLELISATION
      //pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_slot0_dl_processing,NULL);
      //pthread_cond_init(&UE->proc.proc_rxtx[i].cond_slot0_dl_processing,NULL);
      //pthread_create(&UE->proc.proc_rxtx[i].pthread_slot0_dl_processing,NULL,UE_thread_slot0_dl_processing, rtd);

      pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_slot1_dl_processing,NULL);
      pthread_cond_init(&UE->proc.proc_rxtx[i].cond_slot1_dl_processing,NULL);
      pthread_create(&UE->proc.proc_rxtx[i].pthread_slot1_dl_processing,NULL,UE_thread_slot1_dl_processing, rtd);
      #endif*/

  }
  // Panos: Remove thread for UE_sync in phy_stub_UE mode.
  //pthread_create(&UE->proc.pthread_synch,NULL,UE_thread_synch,(void*)UE);
}




1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
/*!
 * \brief Initialize the UE theads.
 * Creates the UE threads:
 * - UE_thread_rxtx0
 * - UE_thread_synch
 * - UE_thread_fep_slot0
 * - UE_thread_fep_slot1
 * - UE_thread_dlsch_proc_slot0
 * - UE_thread_dlsch_proc_slot1
 * and the locking between them.
 */
void init_UE_threads_stub(int inst) {
1907 1908
  struct rx_tx_thread_data *rtd;
  PHY_VARS_UE *UE;
1909

1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947
  AssertFatal(PHY_vars_UE_g!=NULL,"PHY_vars_UE_g is NULL\n");
  AssertFatal(PHY_vars_UE_g[inst]!=NULL,"PHY_vars_UE_g[inst] is NULL\n");
  AssertFatal(PHY_vars_UE_g[inst][0]!=NULL,"PHY_vars_UE_g[inst][0] is NULL\n");
  UE = PHY_vars_UE_g[inst][0];

  pthread_attr_init (&UE->proc.attr_ue);
  pthread_attr_setstacksize(&UE->proc.attr_ue,8192);//5*PTHREAD_STACK_MIN);

  // Panos: Don't need synch for phy_stub mode
  //pthread_mutex_init(&UE->proc.mutex_synch,NULL);
  //pthread_cond_init(&UE->proc.cond_synch,NULL);

  // the threads are not yet active, therefore access is allowed without locking
  // Panos: In phy_stub_UE mode due to less heavy processing operations we don't need two threads
  //int nb_threads=RX_NB_TH;
  int nb_threads=1;
  for (int i=0; i<nb_threads; i++) {
    rtd = calloc(1, sizeof(struct rx_tx_thread_data));
    if (rtd == NULL) abort();
    rtd->UE = UE;
    rtd->proc = &UE->proc.proc_rxtx[i];

    pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_rxtx,NULL);
    pthread_cond_init(&UE->proc.proc_rxtx[i].cond_rxtx,NULL);
    UE->proc.proc_rxtx[i].sub_frame_start=i;
    UE->proc.proc_rxtx[i].sub_frame_step=nb_threads;
    printf("Init_UE_threads rtd %d proc %d nb_threads %d i %d\n",rtd->proc->sub_frame_start, UE->proc.proc_rxtx[i].sub_frame_start,nb_threads, i);
    pthread_create(&UE->proc.proc_rxtx[i].pthread_rxtx, NULL, UE_phy_stub_thread_rxn_txnp4, rtd);
    /*
      #ifdef UE_SLOT_PARALLELISATION
      //pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_slot0_dl_processing,NULL);
      //pthread_cond_init(&UE->proc.proc_rxtx[i].cond_slot0_dl_processing,NULL);
      //pthread_create(&UE->proc.proc_rxtx[i].pthread_slot0_dl_processing,NULL,UE_thread_slot0_dl_processing, rtd);

      pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_slot1_dl_processing,NULL);
      pthread_cond_init(&UE->proc.proc_rxtx[i].cond_slot1_dl_processing,NULL);
      pthread_create(&UE->proc.proc_rxtx[i].pthread_slot1_dl_processing,NULL,UE_thread_slot1_dl_processing, rtd);
      #endif*/
1948

1949
  }
1950 1951
  // Panos: Remove thread for UE_sync in phy_stub_UE mode.
  //pthread_create(&UE->proc.pthread_synch,NULL,UE_thread_synch,(void*)UE);
1952 1953 1954 1955 1956
}




Raymond Knopp's avatar
 
Raymond Knopp committed
1957
#ifdef OPENAIR2
laurent's avatar
laurent committed
1958 1959
void fill_ue_band_info(void) {

1960 1961
  UE_EUTRA_Capability_t *UE_EUTRA_Capability = UE_rrc_inst[0].UECap->UE_EUTRA_Capability;
  int i,j;
laurent's avatar
laurent committed
1962

1963
  bands_to_scan.nbands = UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.count;
laurent's avatar
laurent committed
1964

1965
  for (i=0; i<bands_to_scan.nbands; i++) {
laurent's avatar
laurent committed
1966

1967 1968
    for (j=0; j<sizeof (eutra_bands) / sizeof (eutra_bands[0]); j++)
      if (eutra_bands[j].band == UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.array[i]->bandEUTRA) {
1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
	memcpy(&bands_to_scan.band_info[i],
	       &eutra_bands[j],
	       sizeof(eutra_band_t));

	printf("Band %d (%lu) : DL %u..%u Hz, UL %u..%u Hz, Duplex %s \n",
	       bands_to_scan.band_info[i].band,
	       UE_EUTRA_Capability->rf_Parameters.supportedBandListEUTRA.list.array[i]->bandEUTRA,
	       bands_to_scan.band_info[i].dl_min,
	       bands_to_scan.band_info[i].dl_max,
	       bands_to_scan.band_info[i].ul_min,
	       bands_to_scan.band_info[i].ul_max,
	       (bands_to_scan.band_info[i].frame_type==FDD) ? "FDD" : "TDD");
	break;
      }
1983
  }
1984
}
Raymond Knopp's avatar
 
Raymond Knopp committed
1985
#endif
1986

laurent's avatar
laurent committed
1987
int setup_ue_buffers(PHY_VARS_UE **phy_vars_ue, openair0_config_t *openair0_cfg) {
1988

1989 1990 1991
  int i, CC_id;
  LTE_DL_FRAME_PARMS *frame_parms;
  openair0_rf_map *rf_map;
1992

1993
  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
1994
    rf_map = &phy_vars_ue[CC_id]->rf_map;
1995

1996 1997
    AssertFatal( phy_vars_ue[CC_id] !=0, "");
    frame_parms = &(phy_vars_ue[CC_id]->frame_parms);
1998

1999 2000 2001
    // replace RX signal buffers with mmaped HW versions
    rxdata = (int32_t**)malloc16( frame_parms->nb_antennas_rx*sizeof(int32_t*) );
    txdata = (int32_t**)malloc16( frame_parms->nb_antennas_tx*sizeof(int32_t*) );
2002

2003
    for (i=0; i<frame_parms->nb_antennas_rx; i++) {
2004 2005 2006 2007 2008 2009
      LOG_I(PHY, "Mapping UE CC_id %d, rx_ant %d, freq %u on card %d, chain %d\n",
	    CC_id, i, downlink_frequency[CC_id][i], rf_map->card, rf_map->chain+i );
      free( phy_vars_ue[CC_id]->common_vars.rxdata[i] );
      rxdata[i] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
      phy_vars_ue[CC_id]->common_vars.rxdata[i] = rxdata[i]; // what about the "-N_TA_offset" ? // N_TA offset for TDD
    }
2010

2011
    for (i=0; i<frame_parms->nb_antennas_tx; i++) {
2012 2013 2014 2015 2016
      LOG_I(PHY, "Mapping UE CC_id %d, tx_ant %d, freq %u on card %d, chain %d\n",
	    CC_id, i, downlink_frequency[CC_id][i], rf_map->card, rf_map->chain+i );
      free( phy_vars_ue[CC_id]->common_vars.txdata[i] );
      txdata[i] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
      phy_vars_ue[CC_id]->common_vars.txdata[i] = txdata[i];
2017
    }
2018

2019 2020 2021 2022 2023
    // rxdata[x] points now to the same memory region as phy_vars_ue[CC_id]->common_vars.rxdata[x]
    // txdata[x] points now to the same memory region as phy_vars_ue[CC_id]->common_vars.txdata[x]
    // be careful when releasing memory!
    // because no "release_ue_buffers"-function is available, at least rxdata and txdata memory will leak (only some bytes)
  }
2024
  return 0;
2025
}
2026

2027

2028 2029 2030
// Panos: This timer thread is used only in the phy_sub mode as an independent timer
// which will be ticking and provide the SFN/SF values that will be used from the UE threads
// playing the role of nfapi-pnf.
2031

2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
/*static void* timer_thread( void* param ) {
  thread_top_init("timer_thread",1,870000L,1000000L,1000000L);
  timer_subframe =9;
  timer_frame    =1023;
  //phy_stub_ticking = (SF_ticking*)malloc(sizeof(SF_ticking));
  phy_stub_ticking->ticking_var = -1;
  PHY_VARS_UE *UE;
  UE = PHY_vars_UE_g[0][0];
  double t_diff;
  int external_timer = 0;
2042 2043


2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136
  //struct timespec pselect_start;


  //struct timespec sf_duration;
  //sf_duration.tv_sec = 0;
  //sf_duration.tv_nsec = 1e6;


  wait_sync("timer_thread");

  //pthread_mutex_init(&phy_stub_ticking->mutex_ticking,NULL);
  //pthread_cond_init(&phy_stub_ticking->cond_ticking,NULL);

  //  struct timespec start = {0};
  //  struct timespec end = {0};
  //sleepValue.tv_nsec = 1000000;
  opp_enabled = 1;

  // first check if we are receiving timing indications
  if(nfapi_mode==4) {
  usleep(10000);
  if (UE->instance_cnt_timer > 0) {
    external_timer = 1;
    int absSFm1 = ((emulator_absSF+10239)%10240);
    timer_frame = absSFm1/10;
    timer_subframe = absSFm1%10;
    pthread_mutex_lock(&UE->timer_mutex);
    UE->instance_cnt_timer = -1;
    pthread_mutex_unlock(&UE->timer_mutex);
    LOG_I(PHY,"Running with external timer\n");
  }
  else LOG_I(PHY,"Running with internal timer\n");
  }

  struct timespec t_start;
  struct timespec t_now;
  struct timespec t_sleep;
  uint64_t T_0;
  uint64_t T_now;
  uint64_t T_next_SF;
  uint64_t T_sleep;
  uint64_t sf_cnt = 0; //Total Subframe counter

  clock_gettime(CLOCK_MONOTONIC, &t_start);
  T_0 = (uint64_t) t_start.tv_sec*1000000000 + t_start.tv_nsec;
  LOG_I(MAC, "Panos-D: timer_thread(), T_0 value: %" PRId64 "\n", T_0);
  //printf("%" PRId64 "\n", t);

  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 (timer_subframe==9) {
      timer_subframe=0;
      timer_frame++;
      timer_frame&=1023;
    } else {
      timer_subframe++;
    }
    //printf("[timer_thread] Frame: %d, Subframe: %d \n", timer_frame, timer_subframe);
    //LOG_I(MAC," Panos-D [timer_thread] Frame: %d, Subframe: %d \n", timer_frame, timer_subframe);
    //AssertFatal( 0 == pthread_cond_signal(&phy_stub_ticking->cond_ticking), "");
    AssertFatal(pthread_mutex_lock(&phy_stub_ticking->mutex_ticking) ==0,"");
    phy_stub_ticking->ticking_var++;
    // This should probably be a call to pthread_cond_broadcast when we introduce support for multiple UEs (threads)
    if(phy_stub_ticking->ticking_var == 0){
      //AssertFatal(phy_stub_ticking->ticking_var == 0,"phy_stub_ticking->ticking_var = %d",
      		//phy_stub_ticking->ticking_var);
      if (pthread_cond_signal(&phy_stub_ticking->cond_ticking) != 0) {
	//LOG_E( PHY, "[SCHED][UE %d] ERROR pthread_cond_signal for UE RX thread\n", UE->Mod_id);
	LOG_E( PHY, "timer_thread ERROR pthread_cond_signal for UE_thread\n");
	exit_fun("nothing to add");
      }
    }
    else
    	LOG_I(MAC, "Panos-D: timer_thread() Timing problem! \n");

    AssertFatal(pthread_mutex_unlock(&phy_stub_ticking->mutex_ticking) ==0,"");
    start_meas(&UE->timer_stats);


    //clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); // get initial time-stamp
    if (external_timer == 0) {
    	sf_cnt++;
    	T_next_SF = T_0 + sf_cnt*1000000;
    	do{
    	clock_gettime(CLOCK_MONOTONIC, &t_now);
    	T_now =(uint64_t) t_now.tv_sec*1000000000 + t_now.tv_nsec;
    	}while(T_now < T_next_SF);
      //usleep(1000);
      UE_tport_t pdu;
      pdu.header.packet_type = TTI_SYNC;
      pdu.header.absSF = (timer_frame*10)+timer_subframe;
2137
      if (nfapi_mode!=3){
2138 2139 2140
      multicast_link_write_sock(0,
	  			&pdu,
				sizeof(UE_tport_header_t));
2141
				}
2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197

    }
    else {
      wait_on_condition(&UE->timer_mutex,&UE->timer_cond,&UE->instance_cnt_timer,"timer_thread");
      release_thread(&UE->timer_mutex,&UE->instance_cnt_timer,"timer_thread");
    }
    //clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);   // get final time-stamp

    //double t_ns = (double)(end.tv_sec - start.tv_sec) * 1.0e9 +
    //              (double)(end.tv_nsec - start.tv_nsec);
    //printf("Panos-D: [timer_thread] REAL TIME difference: %f", t_ns);


    stop_meas(&UE->timer_stats);
    t_diff = get_time_meas_us(&UE->timer_stats);

    //printf("Panos-D: Absolute time: %lld, diff: %lld, diff_now: %lld \n",UE->timer_stats.p_time, UE->timer_stats.diff, UE->timer_stats.diff_now);
    //LOG_I(MAC,"[UE%d] Applying default macMainConfig\n",module_idP);
    //if (t_diff > 1100)


    //    LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);
	    //LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);

    //printf("Panos-D: Absolute time: %f", t_diff);


    stop_meas(&UE->timer_stats);
    t_diff = get_time_meas_us(&UE->timer_stats);
    //printf("Panos-D: Absolute time: %lld, diff: %lld, diff_now: %lld \n",UE->timer_stats.p_time, UE->timer_stats.diff, UE->timer_stats.diff_now);
    //LOG_I(MAC,"[UE%d] Applying default macMainConfig\n",module_idP);
    //if (t_diff > 1100) LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);
    //printf("Panos-D: Absolute time: %f", t_diff);

    //UE->proc.ticking_var++;
    // pthread_cond_signal() //Send signal to ue_thread()?
    // We also need to somehow pass the information of SFN/SF
  }
  free(phy_stub_ticking);
  pthread_cond_destroy(&phy_stub_ticking->cond_ticking);
  pthread_mutex_destroy(&phy_stub_ticking->mutex_ticking);
  return 0;

}*/











//02/02/2018
2198
static void* timer_thread( void* param ) {
2199 2200 2201 2202 2203 2204 2205 2206 2207
  thread_top_init("timer_thread",1,870000L,1000000L,1000000L);
  timer_subframe =9;
  timer_frame    =1023;
  //phy_stub_ticking = (SF_ticking*)malloc(sizeof(SF_ticking));
  phy_stub_ticking->ticking_var = -1;
  PHY_VARS_UE *UE;
  UE = PHY_vars_UE_g[0][0];
  double t_diff;
  int external_timer = 0;
2208

2209 2210 2211 2212 2213 2214 2215 2216 2217

  //struct timespec pselect_start;


  //struct timespec sf_duration;
  //sf_duration.tv_sec = 0;
  //sf_duration.tv_nsec = 1e6;


2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
  wait_sync("timer_thread");

  //pthread_mutex_init(&phy_stub_ticking->mutex_ticking,NULL);
  //pthread_cond_init(&phy_stub_ticking->cond_ticking,NULL);

  //  struct timespec start = {0};
  //  struct timespec end = {0};
  //sleepValue.tv_nsec = 1000000;
  opp_enabled = 1;

  // first check if we are receiving timing indications
2229
  if(nfapi_mode==4) {
2230 2231 2232 2233 2234 2235 2236 2237
  usleep(10000);
  if (UE->instance_cnt_timer > 0) {
    external_timer = 1;
    int absSFm1 = ((emulator_absSF+10239)%10240);
    timer_frame = absSFm1/10;
    timer_subframe = absSFm1%10;
    pthread_mutex_lock(&UE->timer_mutex);
    UE->instance_cnt_timer = -1;
Raymond Knopp's avatar
Raymond Knopp committed
2238
    pthread_mutex_unlock(&UE->timer_mutex);
2239 2240 2241
    LOG_I(PHY,"Running with external timer\n");
  }
  else LOG_I(PHY,"Running with internal timer\n");
2242
  }
2243

2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
  struct timespec t_start;
  struct timespec t_now;
  struct timespec t_sleep;
  uint64_t T_0;
  uint64_t T_now;
  uint64_t T_next_SF;
  uint64_t T_sleep;
  uint64_t sf_cnt = 0; //Total Subframe counter

  clock_gettime(CLOCK_MONOTONIC, &t_start);
  T_0 = (uint64_t) t_start.tv_sec*1000000000 + t_start.tv_nsec;
2255 2256
  LOG_I(MAC, "Panos-D: timer_thread(), T_0 value: %" PRId64 "\n", T_0);
  //printf("%" PRId64 "\n", t);
2257

2258
  while (!oai_exit) {
2259

2260 2261 2262
    // 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 (timer_subframe==9) {
2263 2264 2265 2266 2267 2268
      timer_subframe=0;
      timer_frame++;
      timer_frame&=1023;
    } else {
      timer_subframe++;
    }
2269
    //printf("[timer_thread] Frame: %d, Subframe: %d \n", timer_frame, timer_subframe);
Raymond Knopp's avatar
Raymond Knopp committed
2270
    //LOG_I(MAC," Panos-D [timer_thread] Frame: %d, Subframe: %d \n", timer_frame, timer_subframe);
2271 2272 2273 2274 2275
    //AssertFatal( 0 == pthread_cond_signal(&phy_stub_ticking->cond_ticking), "");
    AssertFatal(pthread_mutex_lock(&phy_stub_ticking->mutex_ticking) ==0,"");
    phy_stub_ticking->ticking_var++;
    // This should probably be a call to pthread_cond_broadcast when we introduce support for multiple UEs (threads)
    if(phy_stub_ticking->ticking_var == 0){
2276
      //AssertFatal(phy_stub_ticking->ticking_var == 0,"phy_stub_ticking->ticking_var = %d",
2277
      		//phy_stub_ticking->ticking_var);
2278 2279 2280 2281 2282 2283
      if (pthread_cond_signal(&phy_stub_ticking->cond_ticking) != 0) {
	//LOG_E( PHY, "[SCHED][UE %d] ERROR pthread_cond_signal for UE RX thread\n", UE->Mod_id);
	LOG_E( PHY, "timer_thread ERROR pthread_cond_signal for UE_thread\n");
	exit_fun("nothing to add");
      }
    }
2284 2285
    else
    	LOG_I(MAC, "Panos-D: timer_thread() Timing problem! ticking_var value:%d \n \n \n", phy_stub_ticking->ticking_var);
2286

2287 2288
    AssertFatal(pthread_mutex_unlock(&phy_stub_ticking->mutex_ticking) ==0,"");
    start_meas(&UE->timer_stats);
2289 2290


2291
    //clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); // get initial time-stamp
2292
    if (external_timer == 0) {
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303
    	clock_gettime(CLOCK_MONOTONIC, &t_now);
    	sf_cnt++;
    	T_next_SF = T_0 + sf_cnt*1000000;
    	T_now =(uint64_t) t_now.tv_sec*1000000000 + t_now.tv_nsec;
    	if(T_now > T_next_SF){
    		t_sleep.tv_sec =0;
    	    t_sleep.tv_nsec =0;
    		//T_sleep=0;
    	}
    	else{
    		T_sleep = T_next_SF - T_now;
2304
    		//LOG_I(MAC, "Panos-D: timer_thread(), T_sleep value: %" PRId64 "\n", T_sleep);
2305 2306 2307 2308
    		t_sleep.tv_sec =0;
    		t_sleep.tv_nsec = (__syscall_slong_t) T_sleep;
    	}
      nanosleep(&t_sleep, (struct timespec *)NULL);
2309
      //usleep(T_sleep/1000000);
2310 2311 2312
      UE_tport_t pdu;
      pdu.header.packet_type = TTI_SYNC;
      pdu.header.absSF = (timer_frame*10)+timer_subframe;
2313
      if (nfapi_mode!=3){
2314 2315
      multicast_link_write_sock(0,
				&pdu,
2316
				sizeof(UE_tport_header_t));
2317
      }
2318

2319
    }
Raymond Knopp's avatar
Raymond Knopp committed
2320
    else {
2321 2322 2323
      wait_on_condition(&UE->timer_mutex,&UE->timer_cond,&UE->instance_cnt_timer,"timer_thread");
      release_thread(&UE->timer_mutex,&UE->instance_cnt_timer,"timer_thread");
    }
2324
    //clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);   // get final time-stamp
2325

2326 2327 2328
    //double t_ns = (double)(end.tv_sec - start.tv_sec) * 1.0e9 +
    //              (double)(end.tv_nsec - start.tv_nsec);
    //printf("Panos-D: [timer_thread] REAL TIME difference: %f", t_ns);
2329 2330


2331 2332
    stop_meas(&UE->timer_stats);
    t_diff = get_time_meas_us(&UE->timer_stats);
2333

2334 2335 2336
    //printf("Panos-D: Absolute time: %lld, diff: %lld, diff_now: %lld \n",UE->timer_stats.p_time, UE->timer_stats.diff, UE->timer_stats.diff_now);
    //LOG_I(MAC,"[UE%d] Applying default macMainConfig\n",module_idP);
    //if (t_diff > 1100)
2337 2338


2339
    //    LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);
2340
	    //LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);
2341

2342
    //printf("Panos-D: Absolute time: %f", t_diff);
2343

2344

2345 2346 2347 2348 2349 2350
    stop_meas(&UE->timer_stats);
    t_diff = get_time_meas_us(&UE->timer_stats);
    //printf("Panos-D: Absolute time: %lld, diff: %lld, diff_now: %lld \n",UE->timer_stats.p_time, UE->timer_stats.diff, UE->timer_stats.diff_now);
    //LOG_I(MAC,"[UE%d] Applying default macMainConfig\n",module_idP);
    //if (t_diff > 1100) LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);
    //printf("Panos-D: Absolute time: %f", t_diff);
2351

2352 2353 2354 2355
    //UE->proc.ticking_var++;
    // pthread_cond_signal() //Send signal to ue_thread()?
    // We also need to somehow pass the information of SFN/SF
  }
2356 2357 2358 2359
  free(phy_stub_ticking);
  pthread_cond_destroy(&phy_stub_ticking->cond_ticking);
  pthread_mutex_destroy(&phy_stub_ticking->mutex_ticking);
  return 0;
2360 2361

}
2362

2363 2364 2365 2366 2367 2368






2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381












/*static void* timer_thread( void* param ) {
2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402
  thread_top_init("timer_thread",1,870000L,1000000L,1000000L);
  timer_subframe =9;
  timer_frame    =1023;
  //phy_stub_ticking = (SF_ticking*)malloc(sizeof(SF_ticking));
  phy_stub_ticking->ticking_var = -1;
  PHY_VARS_UE *UE;
  UE = PHY_vars_UE_g[0][0];
  double t_diff;
  int external_timer = 0;

  wait_sync("timer_thread");

  //pthread_mutex_init(&phy_stub_ticking->mutex_ticking,NULL);
  //pthread_cond_init(&phy_stub_ticking->cond_ticking,NULL);

  //  struct timespec start = {0};
  //  struct timespec end = {0};
  //sleepValue.tv_nsec = 1000000;
  opp_enabled = 1;

  // first check if we are receiving timing indications
2403
  if(nfapi_mode==4) {
2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
  usleep(10000);
  if (UE->instance_cnt_timer > 0) {
    external_timer = 1;
    int absSFm1 = ((emulator_absSF+10239)%10240);
    timer_frame = absSFm1/10;
    timer_subframe = absSFm1%10;
    pthread_mutex_lock(&UE->timer_mutex);
    UE->instance_cnt_timer = -1;
    pthread_mutex_unlock(&UE->timer_mutex);
    LOG_I(PHY,"Running with external timer\n");
  }
  else LOG_I(PHY,"Running with internal timer\n");
2416
  }
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502

  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 (timer_subframe==9) {
      timer_subframe=0;
      timer_frame++;
      timer_frame&=1023;
    } else {
      timer_subframe++;
    }
    //printf("[timer_thread] Frame: %d, Subframe: %d \n", timer_frame, timer_subframe);
    //LOG_I(MAC," Panos-D [timer_thread] Frame: %d, Subframe: %d \n", timer_frame, timer_subframe);
    //AssertFatal( 0 == pthread_cond_signal(&phy_stub_ticking->cond_ticking), "");
    AssertFatal(pthread_mutex_lock(&phy_stub_ticking->mutex_ticking) ==0,"");
    phy_stub_ticking->ticking_var++;
    // This should probably be a call to pthread_cond_broadcast when we introduce support for multiple UEs (threads)
    if(phy_stub_ticking->ticking_var == 0){
      //AssertFatal(phy_stub_ticking->ticking_var == 0,"phy_stub_ticking->ticking_var = %d",
      //		phy_stub_ticking->ticking_var);
      if (pthread_cond_signal(&phy_stub_ticking->cond_ticking) != 0) {
	//LOG_E( PHY, "[SCHED][UE %d] ERROR pthread_cond_signal for UE RX thread\n", UE->Mod_id);
	LOG_E( PHY, "timer_thread ERROR pthread_cond_signal for UE_thread\n");
	exit_fun("nothing to add");
      }
    }

    AssertFatal(pthread_mutex_unlock(&phy_stub_ticking->mutex_ticking) ==0,"");
    start_meas(&UE->timer_stats);


    //clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); // get initial time-stamp
    if (external_timer == 0) {
      usleep(1000);
      UE_tport_t pdu;
      pdu.header.packet_type = TTI_SYNC;
      pdu.header.absSF = (timer_frame*10)+timer_subframe;
      multicast_link_write_sock(0,
				&pdu,
				sizeof(UE_tport_header_t));

    }
    else {
      wait_on_condition(&UE->timer_mutex,&UE->timer_cond,&UE->instance_cnt_timer,"timer_thread");
      release_thread(&UE->timer_mutex,&UE->instance_cnt_timer,"timer_thread");
    }
    //clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);   // get final time-stamp

    //double t_ns = (double)(end.tv_sec - start.tv_sec) * 1.0e9 +
    //              (double)(end.tv_nsec - start.tv_nsec);
    //printf("Panos-D: [timer_thread] REAL TIME difference: %f", t_ns);


    stop_meas(&UE->timer_stats);
    t_diff = get_time_meas_us(&UE->timer_stats);

    //printf("Panos-D: Absolute time: %lld, diff: %lld, diff_now: %lld \n",UE->timer_stats.p_time, UE->timer_stats.diff, UE->timer_stats.diff_now);
    //LOG_I(MAC,"[UE%d] Applying default macMainConfig\n",module_idP);
    //if (t_diff > 1100)


    //    LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);
	    //LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);

    //printf("Panos-D: Absolute time: %f", t_diff);


    stop_meas(&UE->timer_stats);
    t_diff = get_time_meas_us(&UE->timer_stats);
    //printf("Panos-D: Absolute time: %lld, diff: %lld, diff_now: %lld \n",UE->timer_stats.p_time, UE->timer_stats.diff, UE->timer_stats.diff_now);
    //LOG_I(MAC,"[UE%d] Applying default macMainConfig\n",module_idP);
    //if (t_diff > 1100) LOG_E(MAC," Panos-D Absolute time: %f\n", t_diff);
    //printf("Panos-D: Absolute time: %f", t_diff);

    //UE->proc.ticking_var++;
    // pthread_cond_signal() //Send signal to ue_thread()?
    // We also need to somehow pass the information of SFN/SF
  }
  free(phy_stub_ticking);
  pthread_cond_destroy(&phy_stub_ticking->cond_ticking);
  pthread_mutex_destroy(&phy_stub_ticking->mutex_ticking);
  return 0;

}*/

2503 2504 2505 2506 2507 2508 2509







2510
int init_timer_thread(void) {
2511 2512 2513
	// Panos: CAREFUL Originally this was set to PHY_VARS_UE *UE=PHY_vars_UE_g[0]
  //PHY_VARS_UE *UE=PHY_vars_UE_g[0];
	PHY_VARS_UE *UE=PHY_vars_UE_g[0][0];
2514
  phy_stub_ticking = (SF_ticking*)malloc(sizeof(SF_ticking));
Raymond Knopp's avatar
Raymond Knopp committed
2515
  pthread_mutex_init(&UE->timer_mutex,NULL);
2516
  pthread_cond_init(&UE->timer_cond,NULL);
Raymond Knopp's avatar
Raymond Knopp committed
2517
  UE->instance_cnt_timer = -1;
2518 2519 2520 2521
  pthread_mutex_init(&phy_stub_ticking->mutex_ticking,NULL);
  pthread_cond_init(&phy_stub_ticking->cond_ticking,NULL);
  pthread_create(&phy_stub_ticking->pthread_timer, NULL, &timer_thread, NULL);
  return 0;
2522
}