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


#define _GNU_SOURCE             /* See feature_test_macros(7) */
#include <sched.h>

#include "T.h"
#include "assertions.h"
#include "PHY/types.h"
#include "PHY/defs_nr_UE.h"
Hongzhi Wang's avatar
Hongzhi Wang committed
30
#include "SCHED_NR_UE/defs.h"
Thomas Laurent's avatar
Thomas Laurent committed
31
32
#include "common/ran_context.h"
#include "common/config/config_userapi.h"
33
//#include "common/utils/threadPool/thread-pool.h"
Thomas Laurent's avatar
Thomas Laurent committed
34
35
36
37
38
39
40
#include "common/utils/load_module_shlib.h"
//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all

#include "../../ARCH/COMMON/common_lib.h"
#include "../../ARCH/ETHERNET/USERSPACE/LIB/if_defs.h"

//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
Francesco Mani's avatar
Francesco Mani committed
41
#include "openair1/PHY/MODULATION/nr_modulation.h"
Thomas Laurent's avatar
Thomas Laurent committed
42
#include "PHY/phy_vars_nr_ue.h"
43
#include "PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h"
Thomas Laurent's avatar
Thomas Laurent committed
44
45
#include "SCHED/sched_common_vars.h"
#include "PHY/MODULATION/modulation_vars.h"
46
#include "PHY/NR_TRANSPORT/nr_dlsch.h"
Thomas Laurent's avatar
Thomas Laurent committed
47
48
49
50
51
//#include "../../SIMU/USER/init_lte.h"

#include "LAYER2/MAC/mac_vars.h"
#include "RRC/LTE/rrc_vars.h"
#include "PHY_INTERFACE/phy_interface_vars.h"
52
#include "openair1/SIMULATION/TOOLS/sim.h"
Thomas Laurent's avatar
Thomas Laurent committed
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#ifdef SMBV
#include "PHY/TOOLS/smbv.h"
unsigned short config_frames[4] = {2,9,11,13};
#endif
#include "common/utils/LOG/log.h"
#include "common/utils/LOG/vcd_signal_dumper.h"

#include "UTIL/OPT/opt.h"
#include "enb_config.h"
//#include "PHY/TOOLS/time_meas.h"

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

#include "intertask_interface.h"

#include "PHY/INIT/phy_init.h"
#include "system.h"
#include <openair2/RRC/NR_UE/rrc_proto.h>
Thomas Laurent's avatar
Thomas Laurent committed
74
75
#include <openair2/LAYER2/NR_MAC_UE/mac_defs.h>
#include <openair2/LAYER2/NR_MAC_UE/mac_proto.h>
Thomas Laurent's avatar
Thomas Laurent committed
76
77
78
#include <openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.h>
#include <openair1/SCHED_NR_UE/fapi_nr_ue_l1.h>

Thomas Laurent's avatar
Thomas Laurent committed
79
/* Callbacks, globals and object handlers */
80

Thomas Laurent's avatar
Thomas Laurent committed
81
82
//#include "stats.h"
// current status is that every UE has a DL scope for a SINGLE eNB (eNB_id=0)
83
#include "PHY/TOOLS/phy_scope_interface.h"
Thomas Laurent's avatar
Thomas Laurent committed
84
#include "PHY/TOOLS/nr_phy_scope.h"
Thomas Laurent's avatar
Thomas Laurent committed
85
#include <executables/nr-uesoftmodem.h>
86
87
#include "executables/softmodem-common.h"
#include "executables/thread-common.h"
Thomas Laurent's avatar
Thomas Laurent committed
88

89
90
#include "nr_nas_msg_sim.h"

91
extern const char *duplex_mode[];
Thomas Laurent's avatar
Thomas Laurent committed
92
THREAD_STRUCT thread_struct;
93
nrUE_params_t nrUE_params;
94

95
// Thread variables
96
97
98
99
100
101
102
103
pthread_cond_t nfapi_sync_cond;
pthread_mutex_t nfapi_sync_mutex;
int nfapi_sync_var=-1; //!< protected by mutex \ref nfapi_sync_mutex
uint16_t sf_ahead=6; //??? value ???
pthread_cond_t sync_cond;
pthread_mutex_t sync_mutex;
int sync_var=-1; //!< protected by mutex \ref sync_mutex.
int config_sync_var=-1;
104
105


106

Thomas Laurent's avatar
Thomas Laurent committed
107
108
109
110
111
112
RAN_CONTEXT_t RC;
volatile int             start_eNB = 0;
volatile int             start_UE = 0;
volatile int             oai_exit = 0;


113
114
extern int16_t  nr_dlsch_demod_shift;
static int      tx_max_power[MAX_NUM_CCs] = {0};
Thomas Laurent's avatar
Thomas Laurent committed
115

116
117
118
int      single_thread_flag = 1;
int                 tddflag = 0;
int                 vcdflag = 0;
119

120
121
122
123
124
125
126
127
double          rx_gain_off = 0.0;
char             *usrp_args = NULL;
char       *rrc_config_path = NULL;
int               dumpframe = 0;

uint64_t        downlink_frequency[MAX_NUM_CCs][4];
int32_t         uplink_frequency_offset[MAX_NUM_CCs][4];
int             rx_input_level_dBm;
Thomas Laurent's avatar
Thomas Laurent committed
128
129
130
131
132
133
134
135
136
137
138

#if MAX_NUM_CCs == 1
rx_gain_t                rx_gain_mode[MAX_NUM_CCs][4] = {{max_gain,max_gain,max_gain,max_gain}};
double tx_gain[MAX_NUM_CCs][4] = {{20,0,0,0}};
double rx_gain[MAX_NUM_CCs][4] = {{110,0,0,0}};
#else
rx_gain_t                rx_gain_mode[MAX_NUM_CCs][4] = {{max_gain,max_gain,max_gain,max_gain},{max_gain,max_gain,max_gain,max_gain}};
double tx_gain[MAX_NUM_CCs][4] = {{20,0,0,0},{20,0,0,0}};
double rx_gain[MAX_NUM_CCs][4] = {{110,0,0,0},{20,0,0,0}};
#endif

139
// UE and OAI config variables
Thomas Laurent's avatar
Thomas Laurent committed
140

141
142
143
144
145
openair0_config_t openair0_cfg[MAX_CARDS];
int16_t           node_synch_ref[MAX_NUM_CCs];
int               otg_enabled;
double            cpuf;

146

147
int          chain_offset = 0;
Guido Casati's avatar
Guido Casati committed
148
int           card_offset = 0;
149
150
151
152
153
uint64_t num_missed_slots = 0; // counter for the number of missed slots
int     transmission_mode = 1;
int            numerology = 0;
int           oaisim_flag = 0;
int            emulate_rf = 0;
Roberto Louro Magueta's avatar
Roberto Louro Magueta committed
154
155
156
uint32_t       N_RB_DL    = 106;
char         uecap_xer_in = 0;
char         uecap_xer[1024];
Thomas Laurent's avatar
Thomas Laurent committed
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

/* see file openair2/LAYER2/MAC/main.c for why abstraction_flag is needed
 * this is very hackish - find a proper solution
 */
uint8_t abstraction_flag=0;

/*---------------------BMC: timespec helpers -----------------------------*/

struct timespec min_diff_time = { .tv_sec = 0, .tv_nsec = 0 };
struct timespec max_diff_time = { .tv_sec = 0, .tv_nsec = 0 };

struct timespec clock_difftime(struct timespec start, struct timespec end) {
  struct timespec temp;

  if ((end.tv_nsec-start.tv_nsec)<0) {
    temp.tv_sec = end.tv_sec-start.tv_sec-1;
    temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
  } else {
    temp.tv_sec = end.tv_sec-start.tv_sec;
    temp.tv_nsec = end.tv_nsec-start.tv_nsec;
  }

  return temp;
}

void print_difftimes(void) {
  LOG_I(HW,"difftimes min = %lu ns ; max = %lu ns\n", min_diff_time.tv_nsec, max_diff_time.tv_nsec);
}
185

186
187
188
189
190
191
192
193
194
195
int create_tasks_nrue(uint32_t ue_nb) {
  LOG_D(NR_RRC, "%s(ue_nb:%d)\n", __FUNCTION__, ue_nb);
  itti_wait_ready(1);

  if (ue_nb > 0) {
    LOG_I(NR_RRC,"create TASK_RRC_NRUE \n");
    if (itti_create_task (TASK_RRC_NRUE, rrc_nrue_task, NULL) < 0) {
      LOG_E(NR_RRC, "Create task for RRC UE failed\n");
      return -1;
    }
196
197
198
199
  if (itti_create_task (TASK_NAS_NRUE, nas_nrue_task, NULL) < 0) {
    LOG_E(NR_RRC, "Create task for NAS UE failed\n");
    return -1;
  }
200
  }
Thomas Laurent's avatar
Thomas Laurent committed
201

202
203
204
  itti_wait_ready(0);
  return 0;
}
205

Thomas Laurent's avatar
Thomas Laurent committed
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
void exit_function(const char *file, const char *function, const int line, const char *s) {
  int CC_id;

  if (s != NULL) {
    printf("%s:%d %s() Exiting OAI softmodem: %s\n",file,line, function, s);
  }

  oai_exit = 1;

  if (PHY_vars_UE_g && PHY_vars_UE_g[0]) {
    for(CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
      if (PHY_vars_UE_g[0][CC_id] && PHY_vars_UE_g[0][CC_id]->rfdevice.trx_end_func)
        PHY_vars_UE_g[0][CC_id]->rfdevice.trx_end_func(&PHY_vars_UE_g[0][CC_id]->rfdevice);
    }
  }

  sleep(1); //allow lte-softmodem threads to exit first
223
  exit(1);
Thomas Laurent's avatar
Thomas Laurent committed
224
225
}

knopp's avatar
knopp committed
226
227
228
uint64_t get_nrUE_optmask(void) {
  return nrUE_params.optmask;
}
Thomas Laurent's avatar
Thomas Laurent committed
229

knopp's avatar
knopp committed
230
231
232
uint64_t set_nrUE_optmask(uint64_t bitmask) {
  nrUE_params.optmask = nrUE_params.optmask | bitmask;
  return nrUE_params.optmask;
Thomas Laurent's avatar
Thomas Laurent committed
233
}
234

235
236
nrUE_params_t *get_nrUE_params(void) {
  return &nrUE_params;
Thomas Laurent's avatar
Thomas Laurent committed
237
}
238
239
/* initialie thread pools used for NRUE processing paralleliation */ 
void init_tpools(uint8_t nun_dlsch_threads) {
Sakthivel Velumani's avatar
Sakthivel Velumani committed
240
241
242
243
244
245
  char *params = NULL;
  if (IS_SOFTMODEM_RFSIM) {
    params = calloc(1,2);
    memcpy(params,"N",1);
  }
  else {
Sakthivel Velumani's avatar
Sakthivel Velumani committed
246
247
    params = calloc(1,(NR_RX_NB_TH*NR_NB_TH_SLOT*3)+1);
    for (int i=0; i<NR_RX_NB_TH*NR_NB_TH_SLOT; i++) {
Sakthivel Velumani's avatar
Sakthivel Velumani committed
248
249
      memcpy(params+(i*3),"-1,",3);
    }
250
251
252
253
  }
  initTpool(params, &(nrUE_params.Tpool), false);
  free(params);
  init_dlsch_tpool( nun_dlsch_threads);
254
}
Thomas Laurent's avatar
Thomas Laurent committed
255
static void get_options(void) {
256

257
258
259
  paramdef_t cmdline_params[] =CMDLINE_NRUEPARAMS_DESC ;
  int numparams = sizeof(cmdline_params)/sizeof(paramdef_t);
  config_process_cmdline( cmdline_params,numparams,NULL);
Thomas Laurent's avatar
Thomas Laurent committed
260
261
262



263
264
265
  if (vcdflag > 0)
    ouput_vcd = 1;

Thomas Laurent's avatar
Thomas Laurent committed
266
267
268
269
270
271
272
273
274
  if ( !(CONFIG_ISFLAGSET(CONFIG_ABORT))  && (!(CONFIG_ISFLAGSET(CONFIG_NOOOPT))) ) {
    // Here the configuration file is the XER encoded UE capabilities
    // Read it in and store in asn1c data structures
    sprintf(uecap_xer,"%stargets/PROJECTS/GENERIC-LTE-EPC/CONF/UE_config.xml",getenv("OPENAIR_HOME"));
    printf("%s\n",uecap_xer);
    uecap_xer_in=1;
  } /* UE with config file  */
}

275
276
// set PHY vars from command line
void set_options(int CC_id, PHY_VARS_NR_UE *UE){
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
  NR_DL_FRAME_PARMS *fp       = &UE->frame_parms;
  paramdef_t cmdline_params[] = CMDLINE_NRUE_PHYPARAMS_DESC ;
  int numparams               = sizeof(cmdline_params)/sizeof(paramdef_t);

  UE->mode = normal_txrx;

  config_process_cmdline( cmdline_params,numparams,NULL);

  int pindex = config_paramidx_fromname(cmdline_params,numparams, CALIBRX_OPT);
  if ( (cmdline_params[pindex].paramflags &  PARAMFLAG_PARAMSET) != 0) UE->mode = rx_calib_ue;
  
  pindex = config_paramidx_fromname(cmdline_params,numparams, CALIBRXMED_OPT);
  if ( (cmdline_params[pindex].paramflags &  PARAMFLAG_PARAMSET) != 0) UE->mode = rx_calib_ue_med;

  pindex = config_paramidx_fromname(cmdline_params,numparams, CALIBRXBYP_OPT);              
  if ( (cmdline_params[pindex].paramflags &  PARAMFLAG_PARAMSET) != 0) UE->mode = rx_calib_ue_byp;

  pindex = config_paramidx_fromname(cmdline_params,numparams, DBGPRACH_OPT); 
  if (cmdline_params[pindex].uptr)
    if ( *(cmdline_params[pindex].uptr) > 0) UE->mode = debug_prach;

  pindex = config_paramidx_fromname(cmdline_params,numparams,NOL2CONNECT_OPT ); 
  if (cmdline_params[pindex].uptr)
    if ( *(cmdline_params[pindex].uptr) > 0)  UE->mode = no_L2_connect;

  pindex = config_paramidx_fromname(cmdline_params,numparams,CALIBPRACH_OPT );
  if (cmdline_params[pindex].uptr)
    if ( *(cmdline_params[pindex].uptr) > 0) UE->mode = calib_prach_tx;

  pindex = config_paramidx_fromname(cmdline_params,numparams,DUMPFRAME_OPT );
  if ((cmdline_params[pindex].paramflags & PARAMFLAG_PARAMSET) != 0)
    UE->mode = rx_dump_frame;
309
310
311
312
313
314
315
316

  // Init power variables
  tx_max_power[CC_id] = tx_max_power[0];
  rx_gain[0][CC_id]   = rx_gain[0][0];
  tx_gain[0][CC_id]   = tx_gain[0][0];

  // Set UE variables
  UE->rx_total_gain_dB     = (int)rx_gain[CC_id][0] + rx_gain_off;
317
  UE->tx_total_gain_dB     = (int)tx_gain[CC_id][0];
318
  UE->tx_power_max_dBm     = tx_max_power[CC_id];
Guido Casati's avatar
Guido Casati committed
319
320
  UE->rf_map.card          = card_offset;
  UE->rf_map.chain         = CC_id + chain_offset;
321

322
323
324

  LOG_I(PHY,"Set UE mode %d, UE_fo_compensation %d, UE_scan_carrier %d, UE_no_timing_correction %d \n", 
  	   UE->mode, UE->UE_fo_compensation, UE->UE_scan_carrier, UE->no_timing_correction);
325
326

  // Set FP variables
327
328
329


  
330
331
332
333
  if (tddflag){
    fp->frame_type = TDD;
    LOG_I(PHY, "Set UE frame_type %d\n", fp->frame_type);
  }
Thomas Laurent's avatar
Thomas Laurent committed
334

335
  fp->N_RB_DL = N_RB_DL;
Roberto Louro Magueta's avatar
Roberto Louro Magueta committed
336
337

  LOG_I(PHY, "Set UE N_RB_DL %d\n", N_RB_DL);
338
  LOG_I(PHY, "Set UE nb_rx_antenna %d, nb_tx_antenna %d, threequarter_fs %d\n", fp->nb_antennas_rx, fp->nb_antennas_tx, fp->threequarter_fs);
Thomas Laurent's avatar
Thomas Laurent committed
339
340
341
342
343

}

void init_openair0(void) {
  int card;
344
  int freq_off = 0;
345
  NR_DL_FRAME_PARMS *frame_parms = &PHY_vars_UE_g[0][0]->frame_parms;
Thomas Laurent's avatar
Thomas Laurent committed
346
347

  for (card=0; card<MAX_CARDS; card++) {
348
    uint64_t dl_carrier, ul_carrier;
349
350
351
352
    openair0_cfg[card].configFilename    = NULL;
    openair0_cfg[card].threequarter_fs   = frame_parms->threequarter_fs;
    openair0_cfg[card].sample_rate       = frame_parms->samples_per_subframe * 1e3;
    openair0_cfg[card].samples_per_frame = frame_parms->samples_per_frame;
Thomas Laurent's avatar
Thomas Laurent committed
353

354
    if (frame_parms->frame_type==TDD)
Thomas Laurent's avatar
Thomas Laurent committed
355
      openair0_cfg[card].duplex_mode = duplex_mode_TDD;
356
    else
Thomas Laurent's avatar
Thomas Laurent committed
357
358
359
      openair0_cfg[card].duplex_mode = duplex_mode_FDD;

    openair0_cfg[card].Mod_id = 0;
360
    openair0_cfg[card].num_rb_dl = frame_parms->N_RB_DL;
361
362
    openair0_cfg[card].clock_source = get_softmodem_params()->clock_source;
    openair0_cfg[card].time_source = get_softmodem_params()->timing_source;
363
364
    openair0_cfg[card].tx_num_channels = min(4, frame_parms->nb_antennas_tx);
    openair0_cfg[card].rx_num_channels = min(4, frame_parms->nb_antennas_rx);
Thomas Laurent's avatar
Thomas Laurent committed
365

366
    LOG_I(PHY, "HW: Configuring card %d, sample_rate %f, tx/rx num_channels %d/%d, duplex_mode %s\n",
367
      card,
368
      openair0_cfg[card].sample_rate,
369
370
371
      openair0_cfg[card].tx_num_channels,
      openair0_cfg[card].rx_num_channels,
      duplex_mode[openair0_cfg[card].duplex_mode]);
Thomas Laurent's avatar
Thomas Laurent committed
372

373
374
    nr_get_carrier_frequencies(frame_parms, &dl_carrier, &ul_carrier);

Francesco Mani's avatar
Francesco Mani committed
375
376
    nr_rf_card_config_freq(&openair0_cfg[card], ul_carrier, dl_carrier, freq_off);
    nr_rf_card_config_gain(&openair0_cfg[card], rx_gain_off);
377
378

    openair0_cfg[card].configFilename = get_softmodem_params()->rf_config_file;
Thomas Laurent's avatar
Thomas Laurent committed
379
380
381
382
383
384

    if (usrp_args) openair0_cfg[card].sdr_addrs = usrp_args;

  }
}

385
386
387
388
389
390
391
392
393
394
void init_pdcp(void) {
  uint32_t pdcp_initmask = (!IS_SOFTMODEM_NOS1) ? LINK_ENB_PDCP_TO_GTPV1U_BIT : (LINK_ENB_PDCP_TO_GTPV1U_BIT | PDCP_USE_NETLINK_BIT | LINK_ENB_PDCP_TO_IP_DRIVER_BIT);

  /*if (IS_SOFTMODEM_BASICSIM || IS_SOFTMODEM_RFSIM || (nfapi_getmode()==NFAPI_UE_STUB_PNF)) {
    pdcp_initmask = pdcp_initmask | UE_NAS_USE_TUN_BIT;
  }*/

  if (IS_SOFTMODEM_NOKRNMOD)
    pdcp_initmask = pdcp_initmask | UE_NAS_USE_TUN_BIT;

395
  /*if (rlc_module_init() != 0) {
Thomas Laurent's avatar
Thomas Laurent committed
396
    LOG_I(RLC, "Problem at RLC initiation \n");
397
398
  }
  pdcp_layer_init();
399
  nr_DRB_preconfiguration();*/
400
  pdcp_layer_init();
401
402
403
404
405
  pdcp_module_init(pdcp_initmask);
  pdcp_set_rlc_data_req_func((send_rlc_data_req_func_t) rlc_data_req);
  pdcp_set_pdcp_data_ind_func((pdcp_data_ind_func_t) pdcp_data_ind);
}

406
// Stupid function addition because UE itti messages queues definition is common with eNB
Thomas Laurent's avatar
Thomas Laurent committed
407
void *rrc_enb_process_msg(void *notUsed) {
Thomas Laurent's avatar
Thomas Laurent committed
408
  return NULL;
409
410
}

Thomas Laurent's avatar
Thomas Laurent committed
411
412
413
414
415
416

int main( int argc, char **argv ) {
  //uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2;
  PHY_VARS_NR_UE *UE[MAX_NUM_CCs];
  start_background_system();

417
  if ( load_configmodule(argc,argv,CONFIG_ENABLECMDLINEONLY) == NULL) {
Thomas Laurent's avatar
Thomas Laurent committed
418
419
    exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
  }
420
  set_softmodem_sighandler();
Thomas Laurent's avatar
Thomas Laurent committed
421
422
423
424
425
426
  CONFIG_SETRTFLAG(CONFIG_NOEXITONHELP);
  memset(openair0_cfg,0,sizeof(openair0_config_t)*MAX_CARDS);
  memset(tx_max_power,0,sizeof(int)*MAX_NUM_CCs);
  // initialize logging
  logInit();
  // get options and fill parameters from configuration file
427
428
429

  get_options (); //Command-line options specific for NRUE

430
  get_common_options(SOFTMODEM_5GUE_BIT );
Sakthivel Velumani's avatar
Sakthivel Velumani committed
431
  init_tpools(nrUE_params.nr_dlsch_parallel);
knopp's avatar
knopp committed
432
  CONFIG_CLEARRTFLAG(CONFIG_NOEXITONHELP);
Thomas Laurent's avatar
Thomas Laurent committed
433
434
435
436
437
#if T_TRACER
  T_Config_Init();
#endif
  //randominit (0);
  set_taus_seed (0);
438

Thomas Laurent's avatar
Thomas Laurent committed
439
  cpuf=get_cpu_freq_GHz();
Laurent Thomas's avatar
Laurent Thomas committed
440
  itti_init(TASK_MAX, tasks_info);
Thomas Laurent's avatar
Thomas Laurent committed
441

442
  init_opt() ;
Sakthivel Velumani's avatar
Sakthivel Velumani committed
443
  load_nrLDPClib();
Thomas Laurent's avatar
Thomas Laurent committed
444

445
446
447
448
  if (ouput_vcd) {
    vcd_signal_dumper_init("/tmp/openair_dump_nrUE.vcd");
  }

449
450
451
452
453
454
  #ifndef PACKAGE_VERSION
#  define PACKAGE_VERSION "UNKNOWN-EXPERIMENTAL"
#endif
  LOG_I(HW, "Version: %s\n", PACKAGE_VERSION);

  init_NR_UE(1,rrc_config_path);
455
  if(IS_SOFTMODEM_NOS1 || get_softmodem_params()->sa)
456
	  init_pdcp();
Thomas Laurent's avatar
Thomas Laurent committed
457
458
459
460
461
462

  NB_UE_INST=1;
  NB_INST=1;
  PHY_vars_UE_g = malloc(sizeof(PHY_VARS_NR_UE **));
  PHY_vars_UE_g[0] = malloc(sizeof(PHY_VARS_NR_UE *)*MAX_NUM_CCs);

463
464
465
  if (get_softmodem_params()->do_ra)
    AssertFatal(get_softmodem_params()->phy_test == 0,"RA and phy_test are mutually exclusive\n");

466
467
468
  if (get_softmodem_params()->sa)
    AssertFatal(get_softmodem_params()->phy_test == 0,"Standalone mode and phy_test are mutually exclusive\n");

Thomas Laurent's avatar
Thomas Laurent committed
469
  for (int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
470

471

472
    PHY_vars_UE_g[0][CC_id] = (PHY_VARS_NR_UE *)malloc(sizeof(PHY_VARS_NR_UE));
Thomas Laurent's avatar
Thomas Laurent committed
473
    UE[CC_id] = PHY_vars_UE_g[0][CC_id];
474
475
    memset(UE[CC_id],0,sizeof(PHY_VARS_NR_UE));

476
477
    set_options(CC_id, UE[CC_id]);

478
479
480
481
482
    NR_UE_MAC_INST_t *mac = get_mac_inst(0);
    if(mac->if_module != NULL && mac->if_module->phy_config_request != NULL)
      mac->if_module->phy_config_request(&mac->phy_config);

    fapi_nr_config_request_t *nrUE_config = &UE[CC_id]->nrUE_config;
483
484
485
486
487
488
489
    if (get_softmodem_params()->sa) { // set frame config to initial values from command line and assume that the SSB is centered on the grid
      nrUE_config->ssb_config.scs_common = get_softmodem_params()->numerology;
      nrUE_config->carrier_config.dl_grid_size[nrUE_config->ssb_config.scs_common] = UE[CC_id]->frame_parms.N_RB_DL;
      nrUE_config->carrier_config.ul_grid_size[nrUE_config->ssb_config.scs_common] = UE[CC_id]->frame_parms.N_RB_DL;
      nrUE_config->carrier_config.dl_frequency =  (downlink_frequency[0][0] -(6*UE[CC_id]->frame_parms.N_RB_DL*(15000<<nrUE_config->ssb_config.scs_common)))/1000;
      nrUE_config->carrier_config.uplink_frequency =  (downlink_frequency[0][0] -(6*UE[CC_id]->frame_parms.N_RB_DL*(15000<<nrUE_config->ssb_config.scs_common)))/1000;
      nrUE_config->ssb_table.ssb_offset_point_a = (UE[CC_id]->frame_parms.N_RB_DL - 20)>>1;
490

491
492
493
494
      // Initialize values, will be updated upon SIB1 reception
      nrUE_config->cell_config.frame_duplex_type = TDD;
      nrUE_config->ssb_table.ssb_mask_list[0].ssb_mask = 0xFFFFFFFF;
      nrUE_config->ssb_table.ssb_period = 1;
495
496
497
498
    }
    
    nr_init_frame_parms_ue(&UE[CC_id]->frame_parms, nrUE_config, 
			   mac->scc == NULL ? 78 : *mac->scc->downlinkConfigCommon->frequencyInfoDL->frequencyBandList.list.array[0]);
499
500

    init_symbol_rotation(&UE[CC_id]->frame_parms);
501
502
    init_nr_ue_vars(UE[CC_id], 0, abstraction_flag);

503
504
    #ifdef FR2_TEST
    // Overwrite DL frequency (for FR2 testing)
505
506
507
    if (downlink_frequency[0][0]!=0){
      frame_parms[CC_id]->dl_CarrierFreq = downlink_frequency[0][0];
      if (frame_parms[CC_id]->frame_type == TDD)
508
        frame_parms[CC_id]->ul_CarrierFreq = downlink_frequency[0][0];
509
    }
510
    #endif
Thomas Laurent's avatar
Thomas Laurent committed
511
512
513
514
515
516
  }

  init_openair0();
  // init UE_PF_PO and mutex lock
  pthread_mutex_init(&ue_pf_po_mutex, NULL);
  memset (&UE_PF_PO[0][0], 0, sizeof(UE_PF_PO_t)*NUMBER_OF_UE_MAX*MAX_NUM_CCs);
Thomas Laurent's avatar
Thomas Laurent committed
517
  configure_linux();
Thomas Laurent's avatar
Thomas Laurent committed
518
  mlockall(MCL_CURRENT | MCL_FUTURE);
519
 
520
  if(IS_SOFTMODEM_DOSCOPE) {
521
    load_softscope("nr",PHY_vars_UE_g[0][0]);
522
  }     
Thomas Laurent's avatar
Thomas Laurent committed
523

knopp's avatar
knopp committed
524
  
Florian Kaltenberger's avatar
Florian Kaltenberger committed
525
526
527
  init_NR_UE_threads(1);
  printf("UE threads created by %ld\n", gettid());
  
Thomas Laurent's avatar
Thomas Laurent committed
528
529
  // wait for end of program
  printf("TYPE <CTRL-C> TO TERMINATE\n");
530

531
532
533
534
  if (create_tasks_nrue(1) < 0) {
    printf("cannot create ITTI tasks\n");
    exit(-1); // need a softer mode
  }
535

Laurent Thomas's avatar
Laurent Thomas committed
536
537
538
539
  // Sleep a while before checking all parameters have been used
  // Some are used directly in external threads, asynchronously
  sleep(20);
  config_check_unknown_cmdlineopt(CONFIG_CHECKALLSECTIONS);
Thomas Laurent's avatar
Thomas Laurent committed
540
541
542
543

  while(true)
    sleep(3600);

544
545
546
  if (ouput_vcd)
    vcd_signal_dumper_close();

Thomas Laurent's avatar
Thomas Laurent committed
547
548
  return 0;
}