rrc_UE.c 272 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

/*! \file rrc_UE.c
23
 * \brief rrc procedures for UE
24 25
 * \author Navid Nikaein and Raymond Knopp
 * \date 2011 - 2014
26 27
 * \version 1.0
 * \company Eurecom
28
 * \email: navid.nikaein@eurecom.fr and raymond.knopp@eurecom.fr
29
 */
30

Lionel Gauthier's avatar
Lionel Gauthier committed
31 32
#define RRC_UE
#define RRC_UE_C
33

34
#include "assertions.h"
35
#include "hashtable.h"
36
#include "asn1_conversions.h"
37
#include "defs.h"
38
#include "PHY/TOOLS/dB_routines.h"
39 40 41 42 43 44
#include "extern.h"
#include "RRC/L2_INTERFACE/openair_rrc_L2_interface.h"
#include "LAYER2/RLC/rlc.h"
#include "COMMON/mac_rrc_primitives.h"
#include "UTIL/LOG/log.h"
#include "UTIL/LOG/vcd_signal_dumper.h"
45 46 47
#ifndef CELLULAR
#include "RRC/LITE/MESSAGES/asn1_msg.h"
#endif
48 49 50 51 52 53 54
#include "RRCConnectionRequest.h"
#include "RRCConnectionReconfiguration.h"
#include "UL-CCCH-Message.h"
#include "DL-CCCH-Message.h"
#include "UL-DCCH-Message.h"
#include "DL-DCCH-Message.h"
#include "BCCH-DL-SCH-Message.h"
55
#include "PCCH-Message.h"
Cedric Roux's avatar
Cedric Roux committed
56
#if defined(Rel10) || defined(Rel14)
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
#include "MCCH-Message.h"
#endif
#include "MeasConfig.h"
#include "MeasGapConfig.h"
#include "MeasObjectEUTRA.h"
#include "TDD-Config.h"
#include "UECapabilityEnquiry.h"
#include "UE-CapabilityRequest.h"
#ifdef PHY_ABSTRACTION
#include "OCG.h"
#include "OCG_extern.h"
#endif
#ifdef USER_MODE
#include "RRC/NAS/nas_config.h"
#include "RRC/NAS/rb_config.h"
#endif
73
#if ENABLE_RAL
Lionel Gauthier's avatar
Lionel Gauthier committed
74 75
#include "rrc_UE_ral.h"
#endif
76 77 78 79 80

#if defined(ENABLE_SECURITY)
# include "UTIL/OSA/osa_defs.h"
#endif

81
#include "pdcp.h"
82
#include "plmn_data.h"
Lionel Gauthier's avatar
Lionel Gauthier committed
83
#include "msc.h"
84

85 86 87 88
#if defined(ENABLE_ITTI)
# include "intertask_interface.h"
#endif

89 90
#include "SIMULATION/TOOLS/defs.h" // for taus

91 92 93
#ifdef Rel14
#include "SL-Preconfiguration-r12.h"

Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
94
//for D2D
95 96 97 98 99
int ctrl_sock_fd;
#define BUFSIZE 1024
struct sockaddr_in prose_app_addr;
int slrb_id;
pthread_mutex_t slrb_mutex;
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
100
#endif
101

102 103 104 105 106 107 108 109 110
#ifdef PHY_EMUL
extern EMULATION_VARS *Emul_vars;
#endif
extern eNB_MAC_INST *eNB_mac_inst;
extern UE_MAC_INST *UE_mac_inst;
#ifdef BIGPHYSAREA
extern void *bigphys_malloc(int);
#endif

111
//#define XER_PRINT
112

113
//extern int8_t dB_fixed2(uint32_t x,uint32_t y);
114

115 116 117 118 119 120 121 122 123
extern void pdcp_config_set_security(
  const protocol_ctxt_t* const  ctxt_pP,
  pdcp_t         * const pdcp_pP,
  const rb_id_t         rb_idP,
  const uint16_t        lc_idP,
  const uint8_t         security_modeP,
  uint8_t        * const kRRCenc,
  uint8_t        * const kRRCint,
  uint8_t        * const  kUPenc);
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146

// internal prototypes

void rrc_ue_process_securityModeCommand( const protocol_ctxt_t* const ctxt_pP, SecurityModeCommand_t* const securityModeCommand, const uint8_t eNB_index );

static int decode_SI( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index );

static int decode_SIB1( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index, const uint8_t rsrq, const uint8_t rsrp );

/** \brief Generates/Encodes RRCConnnectionSetupComplete message at UE
 *  \param ctxt_pP Running context
 *  \param eNB_index Index of corresponding eNB/CH
 *  \param Transaction_id Transaction identifier
 */
static void rrc_ue_generate_RRCConnectionSetupComplete( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index, const uint8_t Transaction_id );

/** \brief Generates/Encodes RRCConnectionReconfigurationComplete message at UE
 *  \param ctxt_pP Running context
 *  \param eNB_index Index of corresponding eNB/CH
 *  \param Transaction_id RRC transaction identifier
 */
static void rrc_ue_generate_RRCConnectionReconfigurationComplete( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index, const uint8_t Transaction_id );

147
static void rrc_ue_generate_MeasurementReport(protocol_ctxt_t* const ctxt_pP, uint8_t eNB_index );
148 149 150 151 152 153 154 155 156 157

static uint8_t check_trigger_meas_event(
  uint8_t module_idP,
  frame_t frameP,
  uint8_t eNB_index,
  uint8_t ue_cnx_index,
  uint8_t meas_index,
  Q_OffsetRange_t ofn, Q_OffsetRange_t ocn, Hysteresis_t hys,
  Q_OffsetRange_t ofs, Q_OffsetRange_t ocs, long a3_offset, TimeToTrigger_t ttt);

Cedric Roux's avatar
Cedric Roux committed
158
#if defined(Rel10) || defined(Rel14)
159
static void decode_MBSFNAreaConfiguration(module_id_t module_idP, uint8_t eNB_index, frame_t frameP,uint8_t mbsfn_sync_area);
Cedric Roux's avatar
Cedric Roux committed
160
#endif
161 162 163 164 165 166 167 168








winckel's avatar
winckel committed
169
/*------------------------------------------------------------------------------*/
Cedric Roux's avatar
Cedric Roux committed
170 171
/* to avoid gcc warnings when compiling with certain options */
#if defined(ENABLE_USE_MME) || ENABLE_RAL
172 173
static Rrc_State_t rrc_get_state (module_id_t ue_mod_idP)
{
Lionel Gauthier's avatar
 
Lionel Gauthier committed
174
  return UE_rrc_inst[ue_mod_idP].RrcState;
winckel's avatar
winckel committed
175
}
Cedric Roux's avatar
Cedric Roux committed
176
#endif
winckel's avatar
winckel committed
177

178 179
static Rrc_Sub_State_t rrc_get_sub_state (module_id_t ue_mod_idP)
{
Lionel Gauthier's avatar
 
Lionel Gauthier committed
180
  return UE_rrc_inst[ue_mod_idP].RrcSubState;
winckel's avatar
winckel committed
181 182
}

183 184
static int rrc_set_state (module_id_t ue_mod_idP, Rrc_State_t state)
{
winckel's avatar
winckel committed
185
  AssertFatal ((RRC_STATE_FIRST <= state) && (state <= RRC_STATE_LAST),
186
               "Invalid state %d!\n", state);
winckel's avatar
winckel committed
187

Lionel Gauthier's avatar
 
Lionel Gauthier committed
188
  if (UE_rrc_inst[ue_mod_idP].RrcState != state) {
189
    UE_rrc_inst[ue_mod_idP].RrcState = state;
winckel's avatar
winckel committed
190

191
#if defined(ENABLE_ITTI)
192 193
    {
      MessageDef *msg_p;
194

195 196 197
      msg_p = itti_alloc_new_message(TASK_RRC_UE, RRC_STATE_IND);
      RRC_STATE_IND(msg_p).state = UE_rrc_inst[ue_mod_idP].RrcState;
      RRC_STATE_IND(msg_p).sub_state = UE_rrc_inst[ue_mod_idP].RrcSubState;
winckel's avatar
winckel committed
198

199
      itti_send_msg_to_task(TASK_UNKNOWN, UE_MODULE_ID_TO_INSTANCE(ue_mod_idP), msg_p);
200
    }
201
#endif
202
    return (1);
winckel's avatar
winckel committed
203 204 205 206 207
  }

  return (0);
}

208
//-----------------------------------------------------------------------------
209
static int rrc_set_sub_state( module_id_t ue_mod_idP, Rrc_Sub_State_t subState )
210
{
211
#if (defined(ENABLE_ITTI) && (defined(ENABLE_USE_MME) || ENABLE_RAL))
212

Lionel Gauthier's avatar
 
Lionel Gauthier committed
213
  switch (UE_rrc_inst[ue_mod_idP].RrcState) {
214 215
  case RRC_STATE_INACTIVE:
    AssertFatal ((RRC_SUB_STATE_INACTIVE_FIRST <= subState) && (subState <= RRC_SUB_STATE_INACTIVE_LAST),
216
                 "Invalid sub state %d for state %d!\n", subState, UE_rrc_inst[ue_mod_idP].RrcState);
217 218 219 220
    break;

  case RRC_STATE_IDLE:
    AssertFatal ((RRC_SUB_STATE_IDLE_FIRST <= subState) && (subState <= RRC_SUB_STATE_IDLE_LAST),
221
                 "Invalid sub state %d for state %d!\n", subState, UE_rrc_inst[ue_mod_idP].RrcState);
222 223 224 225
    break;

  case RRC_STATE_CONNECTED:
    AssertFatal ((RRC_SUB_STATE_CONNECTED_FIRST <= subState) && (subState <= RRC_SUB_STATE_CONNECTED_LAST),
226
                 "Invalid sub state %d for state %d!\n", subState, UE_rrc_inst[ue_mod_idP].RrcState);
227
    break;
winckel's avatar
winckel committed
228
  }
229

230
#endif
winckel's avatar
winckel committed
231

Lionel Gauthier's avatar
 
Lionel Gauthier committed
232
  if (UE_rrc_inst[ue_mod_idP].RrcSubState != subState) {
233
    UE_rrc_inst[ue_mod_idP].RrcSubState = subState;
winckel's avatar
winckel committed
234

235
#if defined(ENABLE_ITTI)
236 237
    {
      MessageDef *msg_p;
winckel's avatar
winckel committed
238

239 240 241
      msg_p = itti_alloc_new_message(TASK_RRC_UE, RRC_STATE_IND);
      RRC_STATE_IND(msg_p).state = UE_rrc_inst[ue_mod_idP].RrcState;
      RRC_STATE_IND(msg_p).sub_state = UE_rrc_inst[ue_mod_idP].RrcSubState;
242

243
      itti_send_msg_to_task(TASK_UNKNOWN, UE_MODULE_ID_TO_INSTANCE(ue_mod_idP), msg_p);
244
    }
245
#endif
246
    return (1);
winckel's avatar
winckel committed
247 248 249 250 251
  }

  return (0);
}

252
//-----------------------------------------------------------------------------
253
void init_SI_UE( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index )
254
{
255 256
  UE_rrc_inst[ctxt_pP->module_id].sizeof_SIB1[eNB_index] = 0;
  UE_rrc_inst[ctxt_pP->module_id].sizeof_SI[eNB_index] = 0;
257 258 259 260 261 262 263 264 265 266 267 268
  UE_rrc_inst[ctxt_pP->module_id].SIB1[eNB_index] = (uint8_t*)malloc16_clear( 32 );
  UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType1_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib2[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType2_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib3[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType3_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib4[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType4_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib5[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType5_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib6[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType6_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib7[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType7_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib8[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType8_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib9[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType9_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib10[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType10_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib11[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType11_t) );
Cedric Roux's avatar
Cedric Roux committed
269
#if defined(Rel10) || defined(Rel14)
270 271 272 273
  UE_rrc_inst[ctxt_pP->module_id].sib12[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType12_r9_t) );
  UE_rrc_inst[ctxt_pP->module_id].sib13[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType13_r9_t) );
#endif
  UE_rrc_inst[ctxt_pP->module_id].SI[eNB_index] = (uint8_t*)malloc16_clear( 64 );
274

275
  UE_rrc_inst[ctxt_pP->module_id].si[eNB_index] = (SystemInformation_t*)malloc16_clear( sizeof(SystemInformation_t) );
276

277
  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus = 0;
278
  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIcnt    = 0;
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
#ifdef Rel14
void init_SL_preconfig(UE_RRC_INST *UE, const uint8_t eNB_index )
{
  LOG_I(RRC,"Initializing Sidelink Pre-configuration for UE\n");

  UE->SL_Preconfiguration[eNB_index] = malloc16_clear( sizeof(struct SL_Preconfiguration_r12) );
  UE->SL_Preconfiguration[eNB_index]->preconfigGeneral_r12.rohc_Profiles_r12.profile0x0001_r12       = true;
  UE->SL_Preconfiguration[eNB_index]->preconfigGeneral_r12.carrierFreq_r12                           = 3350;
  UE->SL_Preconfiguration[eNB_index]->preconfigGeneral_r12.maxTxPower_r12                            = 0;
  UE->SL_Preconfiguration[eNB_index]->preconfigGeneral_r12.additionalSpectrumEmission_r12            = 0;
  UE->SL_Preconfiguration[eNB_index]->preconfigGeneral_r12.sl_bandwidth_r12                          = SL_PreconfigGeneral_r12__sl_bandwidth_r12_n50;
  UE->SL_Preconfiguration[eNB_index]->preconfigGeneral_r12.tdd_ConfigSL_r12.subframeAssignmentSL_r12 = TDD_ConfigSL_r12__subframeAssignmentSL_r12_none;

  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.syncCP_Len_r12            = SL_CP_Len_r12_normal;
  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.syncOffsetIndicator1_r12  = 0;
  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.syncOffsetIndicator2_r12  = 0;
  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.syncTxParameters_r12      = 0;
  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.syncTxThreshOoC_r12       = 0;
  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.filterCoefficient_r12     = FilterCoefficient_fc0;
  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.syncRefMinHyst_r12        = SL_PreconfigSync_r12__syncRefMinHyst_r12_dB0;
  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.syncRefDiffHyst_r12       = SL_PreconfigSync_r12__syncRefDiffHyst_r12_dB0;
  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.ext1                      = malloc16_clear(sizeof(struct SL_PreconfigSync_r12__ext1));
  UE->SL_Preconfiguration[eNB_index]->preconfigSync_r12.ext1->syncTxPeriodic_r13  = NULL;

  struct SL_PreconfigCommPool_r12 *preconfigpool = malloc16_clear(sizeof(struct SL_PreconfigCommPool_r12));
  preconfigpool->sc_CP_Len_r12                                                    = SL_CP_Len_r12_normal;
  preconfigpool->sc_Period_r12                                                    = SL_PeriodComm_r12_sf40;
  // 20 PRBs for SL communications
309 310
  preconfigpool->sc_TF_ResourceConfig_r12.prb_Num_r12                             = 20;
  preconfigpool->sc_TF_ResourceConfig_r12.prb_Start_r12                           = 5;
311 312 313
  preconfigpool->sc_TF_ResourceConfig_r12.prb_End_r12                             = 44;
  // Offset set to 0 subframes
  preconfigpool->sc_TF_ResourceConfig_r12.offsetIndicator_r12.present             = SL_OffsetIndicator_r12_PR_small_r12;
314
  preconfigpool->sc_TF_ResourceConfig_r12.offsetIndicator_r12.choice.small_r12    = 0;
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
  // 40 ms SL Period
  preconfigpool->sc_TF_ResourceConfig_r12.subframeBitmap_r12.present              = SubframeBitmapSL_r12_PR_bs40_r12;
  preconfigpool->sc_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf         = CALLOC(1,5);
  preconfigpool->sc_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.size        = 5;
  preconfigpool->sc_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.bits_unused = 0;
  // 1st 4 subframes for PSCCH
  preconfigpool->sc_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[0]      = 0xF;
  preconfigpool->sc_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[1]      = 0;
  preconfigpool->sc_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[2]      = 0;
  preconfigpool->sc_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[3]      = 0;
  preconfigpool->sc_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[4]      = 0;
  preconfigpool->sc_TxParameters_r12                                              = 0;

  preconfigpool->data_CP_Len_r12                                                  = SL_CP_Len_r12_normal;
  // 20 PRBs for SL communications
330 331
  preconfigpool->data_TF_ResourceConfig_r12.prb_Num_r12                             = 20;
  preconfigpool->data_TF_ResourceConfig_r12.prb_Start_r12                           = 5;
332 333 334
  preconfigpool->data_TF_ResourceConfig_r12.prb_End_r12                             = 44;
  // Offset set to 0 subframes
  preconfigpool->data_TF_ResourceConfig_r12.offsetIndicator_r12.present             = SL_OffsetIndicator_r12_PR_small_r12;
335
  preconfigpool->data_TF_ResourceConfig_r12.offsetIndicator_r12.choice.small_r12    = 0;
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
  // 40 ms SL Period
  preconfigpool->data_TF_ResourceConfig_r12.subframeBitmap_r12.present              = SubframeBitmapSL_r12_PR_bs40_r12;
  preconfigpool->data_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf         = CALLOC(1,5);
  preconfigpool->data_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.size        = 5;
  preconfigpool->data_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.bits_unused = 0;
  // last 36 subframes for PSCCH
  preconfigpool->data_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[0]      = 0xF0;
  preconfigpool->data_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[1]      = 0xFF;
  preconfigpool->data_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[2]      = 0xFF;
  preconfigpool->data_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[3]      = 0xFF;
  preconfigpool->data_TF_ResourceConfig_r12.subframeBitmap_r12.choice.bs40_r12.buf[5]      = 0xFF;

  preconfigpool->dataHoppingConfig_r12.hoppingParameter_r12                         = 0;
  preconfigpool->dataHoppingConfig_r12.numSubbands_r12                              = SL_HoppingConfigComm_r12__numSubbands_r12_ns1;
  preconfigpool->dataHoppingConfig_r12.rb_Offset_r12                                = 0;

  preconfigpool->dataTxParameters_r12                                               = 0;

  ASN_SEQUENCE_ADD(&UE->SL_Preconfiguration[eNB_index]->preconfigComm_r12.list,preconfigpool);

  // Rel13 extensions
  UE->SL_Preconfiguration[eNB_index]->ext1 = NULL;
358
/*
359
  // Establish a SLRB (using DRB 3 for now)
360 361 362
  protocol_ctxt_t ctxt;
  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, 0, ENB_FLAG_NO, 0x1234, 0, 0,0);

363 364 365 366 367 368 369 370
  UE->DRB_config[0][0] = CALLOC(1,sizeof(struct DRB_ToAddMod));
  UE->DRB_config[0][0]->eps_BearerIdentity = CALLOC(1, sizeof(long));
  UE->DRB_config[0][0]->drb_Identity =  3;
  UE->DRB_config[0][0]->eps_BearerIdentity = CALLOC(1, sizeof(long));
  // allowed value 5..15, value : x+4
  *(UE->DRB_config[0][0]->eps_BearerIdentity) = 3;
  UE->DRB_config[0][0]->logicalChannelIdentity = CALLOC(1, sizeof(long));
  *(UE->DRB_config[0][0]->logicalChannelIdentity) = UE->DRB_config[0][0]->drb_Identity; //(long) (ue_context_pP->ue_context.e_rab[i].param.e_rab_id + 2); // value : x+2
371

372 373 374 375 376 377 378 379 380
  // TTN - Establish a new SLRB for PC5-S (using DRB 10 for now)
  UE->DRB_config[0][1] = CALLOC(1,sizeof(struct DRB_ToAddMod));
  UE->DRB_config[0][1]->eps_BearerIdentity = CALLOC(1, sizeof(long));
  UE->DRB_config[0][1]->drb_Identity =  10;
  UE->DRB_config[0][1]->eps_BearerIdentity = CALLOC(1, sizeof(long));
  // allowed value 5..15, value : x+4
  *(UE->DRB_config[0][1]->eps_BearerIdentity) = 10;
  UE->DRB_config[0][1]->logicalChannelIdentity = CALLOC(1, sizeof(long));
  *(UE->DRB_config[0][1]->logicalChannelIdentity) = UE->DRB_config[0][1]->drb_Identity; //(long) (ue_context_pP->ue_context.e_rab[i].param.e_rab_id + 2); // value : x+2
381 382 383 384 385 386 387 388 389 390 391 392 393 394

  struct RLC_Config                  *DRB_rlc_config                   = CALLOC(1,sizeof(struct RLC_Config));
  struct PDCP_Config                 *DRB_pdcp_config                  = CALLOC(1,sizeof(struct PDCP_Config));
  struct PDCP_Config__rlc_UM         *PDCP_rlc_UM                      = CALLOC(1,sizeof(struct PDCP_Config__rlc_UM));
  struct LogicalChannelConfig        *DRB_lchan_config                 = CALLOC(1,sizeof(struct LogicalChannelConfig));
  struct LogicalChannelConfig__ul_SpecificParameters
    *DRB_ul_SpecificParameters                                         = CALLOC(1, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
  long                               *logicalchannelgroup_drb          = CALLOC(1, sizeof(long));

  DRB_rlc_config->present = RLC_Config_PR_um_Bi_Directional;
  DRB_rlc_config->choice.um_Bi_Directional.ul_UM_RLC.sn_FieldLength = SN_FieldLength_size10;
  DRB_rlc_config->choice.um_Bi_Directional.dl_UM_RLC.sn_FieldLength = SN_FieldLength_size10;
  DRB_rlc_config->choice.um_Bi_Directional.dl_UM_RLC.t_Reordering = T_Reordering_ms35;
  UE->DRB_config[0][0]->rlc_Config = DRB_rlc_config;
395
  UE->DRB_config[0][1]->rlc_Config = DRB_rlc_config;
396 397 398

  DRB_pdcp_config = CALLOC(1, sizeof(*DRB_pdcp_config));
  UE->DRB_config[0][0]->pdcp_Config = DRB_pdcp_config;
399
  UE->DRB_config[0][1]->pdcp_Config = DRB_pdcp_config;
400 401 402 403 404
  DRB_pdcp_config->discardTimer = CALLOC(1, sizeof(long));
  *DRB_pdcp_config->discardTimer = PDCP_Config__discardTimer_infinity;
  DRB_pdcp_config->rlc_AM = NULL;
  DRB_pdcp_config->rlc_UM = NULL;

405
  // avoid gcc warnings
406 407 408 409 410 411 412
  (void)PDCP_rlc_UM;

  DRB_pdcp_config->rlc_UM = PDCP_rlc_UM;
  PDCP_rlc_UM->pdcp_SN_Size = PDCP_Config__rlc_UM__pdcp_SN_Size_len12bits;
  DRB_pdcp_config->headerCompression.present = PDCP_Config__headerCompression_PR_notUsed;

  UE->DRB_config[0][0]->logicalChannelConfig = DRB_lchan_config;
413
  UE->DRB_config[0][1]->logicalChannelConfig = DRB_lchan_config;
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
  DRB_ul_SpecificParameters = CALLOC(1, sizeof(*DRB_ul_SpecificParameters));
  DRB_lchan_config->ul_SpecificParameters = DRB_ul_SpecificParameters;

  DRB_ul_SpecificParameters->priority = 12;    // lower priority than srb1, srb2 and other dedicated bearer
  DRB_ul_SpecificParameters->prioritisedBitRate =LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_kBps8 ;
    //LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_infinity;
  DRB_ul_SpecificParameters->bucketSizeDuration =
    LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms50;

  // LCG for DTCH can take the value from 1 to 3 as defined in 36331: normally controlled by upper layers (like RRM)

  *logicalchannelgroup_drb = 1;
  DRB_ul_SpecificParameters->logicalChannelGroup = logicalchannelgroup_drb;

  UE->DRB_configList = CALLOC(1,sizeof(DRB_ToAddModList_t));
  ASN_SEQUENCE_ADD(&UE->DRB_configList->list,UE->DRB_config[0][0]);
430
  ASN_SEQUENCE_ADD(&UE->DRB_configList->list,UE->DRB_config[0][1]);
431 432 433 434 435 436 437 438 439

  rrc_pdcp_config_asn1_req(&ctxt,
			   (SRB_ToAddModList_t *) NULL,
			   UE->DRB_configList,
			   (DRB_ToReleaseList_t*) NULL,
			   0xff, NULL, NULL, NULL
#if defined(Rel10) || defined(Rel14)
                           , (PMCH_InfoList_r9_t *) NULL
#endif
440 441
                           ,NULL);

442 443 444 445 446 447 448 449
  rrc_rlc_config_asn1_req(&ctxt,
			  (SRB_ToAddModList_t*)NULL,
			  UE->DRB_configList,
			  (DRB_ToReleaseList_t*)NULL
#if defined(Rel10) || defined(Rel14)
			  ,(PMCH_InfoList_r9_t *)NULL
#endif
			  );
450
*/
451 452 453 454
}

#endif

Cedric Roux's avatar
Cedric Roux committed
455
#if defined(Rel10) || defined(Rel14)
456
//-----------------------------------------------------------------------------
457
#if 0
458
void init_MCCH_UE(module_id_t ue_mod_idP, uint8_t eNB_index)
459
{
460
  int i;
Lionel Gauthier's avatar
 
Lionel Gauthier committed
461 462 463
  UE_rrc_inst[ue_mod_idP].sizeof_MCCH_MESSAGE[eNB_index] = 0;
  UE_rrc_inst[ue_mod_idP].MCCH_MESSAGE[eNB_index] = (uint8_t *)malloc16(32);
  UE_rrc_inst[ue_mod_idP].mcch_message[eNB_index] = (MBSFNAreaConfiguration_r9_t *)malloc16(sizeof(MBSFNAreaConfiguration_r9_t));
464

465
  for (i=0; i<8; i++) { // MAX MBSFN Area
Lionel Gauthier's avatar
 
Lionel Gauthier committed
466
    UE_rrc_inst[ue_mod_idP].Info[eNB_index].MCCHStatus[i] = 0;
467

468
  }
469 470
}
#endif
471
#endif
472

473
//-----------------------------------------------------------------------------
474
void openair_rrc_ue_init_security( const protocol_ctxt_t* const ctxt_pP )
475 476
{
#if defined(ENABLE_SECURITY)
477 478 479 480
  //    uint8_t *kRRCenc;
  //    uint8_t *kRRCint;
  char ascii_buffer[65];
  uint8_t i;
481

482
  memset(UE_rrc_inst[ctxt_pP->module_id].kenb, ctxt_pP->module_id, 32);
483

484
  for (i = 0; i < 32; i++) {
485
    sprintf(&ascii_buffer[2 * i], "%02X", UE_rrc_inst[ctxt_pP->module_id].kenb[i]);
486
  }
487

488 489 490
  LOG_T(RRC, PROTOCOL_RRC_CTXT_FMT"[OSA] kenb    = %s\n",
        PROTOCOL_RRC_CTXT_ARGS(ctxt_pP),
        ascii_buffer);
491
#endif
492
}
493

494
//-----------------------------------------------------------------------------
495
char openair_rrc_ue_init( const module_id_t ue_mod_idP, const unsigned char eNB_index )
496
{
497
  protocol_ctxt_t ctxt;
498
  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_idP, ENB_FLAG_NO, NOT_A_RNTI, 0, 0,eNB_index);
499 500 501
  LOG_I(RRC,
        PROTOCOL_RRC_CTXT_FMT" Init...\n",
        PROTOCOL_RRC_CTXT_ARGS(&ctxt));
Lionel Gauthier's avatar
 
Lionel Gauthier committed
502 503 504
  rrc_set_state (ue_mod_idP, RRC_STATE_INACTIVE);
  rrc_set_sub_state (ue_mod_idP, RRC_SUB_STATE_INACTIVE);

505 506 507 508 509 510 511 512 513 514
  LOG_D(RRC,"[UE %d] INIT State = RRC_IDLE (eNB %d)\n",ctxt.module_id,eNB_index);
  UE_rrc_inst[ctxt.module_id].Info[eNB_index].State=RRC_IDLE;
  UE_rrc_inst[ctxt.module_id].Info[eNB_index].T300_active = 0;
  UE_rrc_inst[ctxt.module_id].Info[eNB_index].T304_active = 0;
  UE_rrc_inst[ctxt.module_id].Info[eNB_index].T310_active = 0;
  UE_rrc_inst[ctxt.module_id].Info[eNB_index].UE_index=0xffff;
  UE_rrc_inst[ctxt.module_id].Srb0[eNB_index].Active=0;
  UE_rrc_inst[ctxt.module_id].Srb1[eNB_index].Active=0;
  UE_rrc_inst[ctxt.module_id].Srb2[eNB_index].Active=0;
  UE_rrc_inst[ctxt.module_id].HandoverInfoUe.measFlag=1;
Cedric Roux's avatar
Cedric Roux committed
515 516
  UE_rrc_inst[ctxt.module_id].ciphering_algorithm = CipheringAlgorithm_r12_eea0;
#if defined(Rel10) || defined(Rel14)
517
  UE_rrc_inst[ctxt.module_id].integrity_algorithm = SecurityAlgorithmConfig__integrityProtAlgorithm_eia0_v920;
518
#else
519
  UE_rrc_inst[ctxt.module_id].integrity_algorithm = SecurityAlgorithmConfig__integrityProtAlgorithm_reserved;
520 521
#endif

522
  openair_rrc_ue_init_security(&ctxt);
523 524 525
  init_SI_UE(&ctxt,eNB_index);
  LOG_D(RRC,PROTOCOL_RRC_CTXT_FMT"  INIT: phy_sync_2_ch_ind\n",
        PROTOCOL_RRC_CTXT_ARGS(&ctxt));
526

527 528 529 530 531 532


#ifndef NO_RRM
  send_msg(&S_rrc,msg_rrc_phy_synch_to_CH_ind(ctxt.module_id,eNB_index,UE_rrc_inst[ctxt.module_id].Mac_id));
#endif

533
#ifndef NO_RRM
534
  send_msg(&S_rrc,msg_rrc_phy_synch_to_CH_ind(ctxt.module_id,eNB_index,UE_rrc_inst[ctxt.module_id].Mac_id));
535 536 537
#endif

#ifdef NO_RRM //init ch SRB0, SRB1 & BDTCH
538
  openair_rrc_on(&ctxt);
539
#endif
540
#ifdef CBA
541
  int j;
542

543
  for(j=0; j<NUM_MAX_CBA_GROUP; j++) {
Lionel Gauthier's avatar
 
Lionel Gauthier committed
544
    UE_rrc_inst[ue_mod_idP].cba_rnti[j] = 0x0000;
545
  }
546

Lionel Gauthier's avatar
 
Lionel Gauthier committed
547
  UE_rrc_inst[ue_mod_idP].num_active_cba_groups = 0;
548 549 550 551 552
#endif

  return 0;
}

553
//-----------------------------------------------------------------------------
554
void rrc_ue_generate_RRCConnectionRequest( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index )
555
{
556

557
  uint8_t i=0,rv[6];
558

559
  if(UE_rrc_inst[ctxt_pP->module_id].Srb0[eNB_index].Tx_buffer.payload_size ==0) {
560

561 562 563 564 565 566
    // Get RRCConnectionRequest, fill random for now
    // Generate random byte stream for contention resolution
    for (i=0; i<6; i++) {
#ifdef SMBV
      // if SMBV is configured the contention resolution needs to be fix for the connection procedure to succeed
      rv[i]=i;
567
#else
568
      rv[i]=taus()&0xff;
569
#endif
570 571
      LOG_T(RRC,"%x.",rv[i]);
    }
572

573
    LOG_T(RRC,"\n");
574 575 576 577 578
    UE_rrc_inst[ctxt_pP->module_id].Srb0[eNB_index].Tx_buffer.payload_size =
      do_RRCConnectionRequest(
        ctxt_pP->module_id,
        (uint8_t*)UE_rrc_inst[ctxt_pP->module_id].Srb0[eNB_index].Tx_buffer.Payload,
        rv);
579 580

    LOG_I(RRC,"[UE %d] : Frame %d, Logical Channel UL-CCCH (SRB0), Generating RRCConnectionRequest (bytes %d, eNB %d)\n",
581
          ctxt_pP->module_id, ctxt_pP->frame, UE_rrc_inst[ctxt_pP->module_id].Srb0[eNB_index].Tx_buffer.payload_size, eNB_index);
582

583 584
    for (i=0; i<UE_rrc_inst[ctxt_pP->module_id].Srb0[eNB_index].Tx_buffer.payload_size; i++) {
      LOG_T(RRC,"%x.",UE_rrc_inst[ctxt_pP->module_id].Srb0[eNB_index].Tx_buffer.Payload[i]);
585 586 587
    }

    LOG_T(RRC,"\n");
588 589
    /*UE_rrc_inst[ue_mod_idP].Srb0[Idx].Tx_buffer.Payload[i] = taus()&0xff;
    UE_rrc_inst[ue_mod_idP].Srb0[Idx].Tx_buffer.payload_size =i; */
590 591 592 593 594 595 596

  }
}


mui_t rrc_mui=0;

597
#if !(defined(ENABLE_ITTI) && defined(ENABLE_USE_MME))
598
/* NAS Attach request with IMSI */
599
static const char const nas_attach_req_imsi[] = {
600 601 602 603 604 605 606 607 608 609 610
  0x07, 0x41,
  /* EPS Mobile identity = IMSI */
  0x71, 0x08, 0x29, 0x80, 0x43, 0x21, 0x43, 0x65, 0x87,
  0xF9,
  /* End of EPS Mobile Identity */
  0x02, 0xE0, 0xE0, 0x00, 0x20, 0x02, 0x03,
  0xD0, 0x11, 0x27, 0x1A, 0x80, 0x80, 0x21, 0x10, 0x01, 0x00, 0x00,
  0x10, 0x81, 0x06, 0x00, 0x00, 0x00, 0x00, 0x83, 0x06, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x0A, 0x00, 0x52, 0x12, 0xF2,
  0x01, 0x27, 0x11,
};
611
#endif /* !(defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)) */
612

613
#if 0
614
/* NAS Attach request with GUTI */
615
static const char const nas_attach_req_guti[] = {
616 617 618 619 620 621 622 623 624 625 626
  0x07, 0x41,
  /* EPS Mobile identity = GUTI */
  0x71, 0x0B, 0xF6, 0x12, 0xF2, 0x01, 0x80, 0x00, 0x01, 0xE0, 0x00,
  0xDA, 0x1F,
  /* End of EPS Mobile Identity */
  0x02, 0xE0, 0xE0, 0x00, 0x20, 0x02, 0x03,
  0xD0, 0x11, 0x27, 0x1A, 0x80, 0x80, 0x21, 0x10, 0x01, 0x00, 0x00,
  0x10, 0x81, 0x06, 0x00, 0x00, 0x00, 0x00, 0x83, 0x06, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x0A, 0x00, 0x52, 0x12, 0xF2,
  0x01, 0x27, 0x11,
};
627
#endif
628

629
//-----------------------------------------------------------------------------
630
void rrc_ue_generate_RRCConnectionSetupComplete( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index, const uint8_t Transaction_id )
631
{
632

633 634
  uint8_t    buffer[100];
  uint8_t    size;
635
  const char * nas_msg;
winckel's avatar
winckel committed
636
  int   nas_msg_length;
637

winckel's avatar
winckel committed
638
#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
639 640
  nas_msg         = (char*) UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.data;
  nas_msg_length  = UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.length;
winckel's avatar
winckel committed
641 642 643 644 645
#else
  nas_msg         = nas_attach_req_imsi;
  nas_msg_length  = sizeof(nas_attach_req_imsi);
#endif

646
  size = do_RRCConnectionSetupComplete(ctxt_pP->module_id, buffer, Transaction_id, nas_msg_length, nas_msg);
647 648

  LOG_I(RRC,"[UE %d][RAPROC] Frame %d : Logical Channel UL-DCCH (SRB1), Generating RRCConnectionSetupComplete (bytes%d, eNB %d)\n",
649 650
        ctxt_pP->module_id,ctxt_pP->frame, size, eNB_index);
  LOG_D(RLC,
Lionel Gauthier's avatar
Lionel Gauthier committed
651
        "[FRAME %05d][RRC_UE][MOD %02d][][--- PDCP_DATA_REQ/%d Bytes (RRCConnectionSetupComplete to eNB %d MUI %d) --->][PDCP][MOD %02d][RB %02d]\n",
652
        ctxt_pP->frame, ctxt_pP->module_id+NB_eNB_INST, size, eNB_index, rrc_mui, ctxt_pP->module_id+NB_eNB_INST, DCCH);
653 654 655 656 657 658 659 660
  rrc_data_req (
		ctxt_pP,
		DCCH,
		rrc_mui++,
		SDU_CONFIRM_NO,
		size,
		buffer,
		PDCP_TRANSMISSION_MODE_CONTROL);
661 662
}

663
//-----------------------------------------------------------------------------
664
void rrc_ue_generate_RRCConnectionReconfigurationComplete( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index, const uint8_t Transaction_id )
665
{
666

667
  uint8_t buffer[32], size;
668 669 670 671
  size = do_RRCConnectionReconfigurationComplete(ctxt_pP, buffer, Transaction_id);
  LOG_I(RRC,PROTOCOL_RRC_CTXT_UE_FMT" Logical Channel UL-DCCH (SRB1), Generating RRCConnectionReconfigurationComplete (bytes %d, eNB_index %d)\n",
        PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), size, eNB_index);
  LOG_D(RLC,
Lionel Gauthier's avatar
Lionel Gauthier committed
672
        "[FRAME %05d][RRC_UE][INST %02d][][--- PDCP_DATA_REQ/%d Bytes (RRCConnectionReconfigurationComplete to eNB %d MUI %d) --->][PDCP][INST %02d][RB %02d]\n",
673 674 675 676 677 678 679
        ctxt_pP->frame,
        UE_MODULE_ID_TO_INSTANCE(ctxt_pP->module_id),
        size,
        eNB_index,
        rrc_mui,
        UE_MODULE_ID_TO_INSTANCE(ctxt_pP->module_id),
        DCCH);
680 681 682 683 684 685 686 687
  rrc_data_req (
		ctxt_pP,
		DCCH,
		rrc_mui++,
		SDU_CONFIRM_NO,
		size,
		buffer,
		PDCP_TRANSMISSION_MODE_CONTROL);
688 689 690
}


691 692
//-----------------------------------------------------------------------------
// Called by L2 interface (MAC)
693
int rrc_ue_decode_ccch( const protocol_ctxt_t* const ctxt_pP, const SRB_INFO* const Srb_info, const uint8_t eNB_index )
694 695
{
  DL_CCCH_Message_t* dl_ccch_msg=NULL;
696
  asn_dec_rval_t dec_rval;
697
  int rval=0;
698

699
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_IN);
Lionel Gauthier's avatar
 
Lionel Gauthier committed
700 701
  //  LOG_D(RRC,"[UE %d] Decoding DL-CCCH message (%d bytes), State %d\n",ue_mod_idP,Srb_info->Rx_buffer.payload_size,
  //  UE_rrc_inst[ue_mod_idP].Info[eNB_index].State);
702 703

  dec_rval = uper_decode(NULL,
704 705 706 707
                         &asn_DEF_DL_CCCH_Message,
                         (void**)&dl_ccch_msg,
                         (uint8_t*)Srb_info->Rx_buffer.Payload,
                         100,0,0);
708 709 710 711 712

#ifdef XER_PRINT
  xer_fprint(stdout,&asn_DEF_DL_CCCH_Message,(void*)dl_ccch_msg);
#endif

713
#if defined(ENABLE_ITTI)
714
# if defined(DISABLE_ITTI_XER_PRINT)
715
  {
winckel's avatar
winckel committed
716
    MessageDef *msg_p;
717

winckel's avatar
winckel committed
718 719
    msg_p = itti_alloc_new_message (TASK_RRC_UE, RRC_DL_CCCH_MESSAGE);
    memcpy (&msg_p->ittiMsg, (void *) dl_ccch_msg, sizeof(RrcDlCcchMessage));
720

721
    itti_send_msg_to_task (TASK_UNKNOWN, ctxt_pP->instance, msg_p);
722
  }
723 724
# else
  {
725 726
    char        message_string[10000];
    size_t      message_string_size;
727

728 729
    if ((message_string_size = xer_sprint(message_string, sizeof(message_string), &asn_DEF_DL_CCCH_Message, (void *)dl_ccch_msg)) > 0) {
      MessageDef *msg_p;
730

731 732 733
      msg_p = itti_alloc_new_message_sized (TASK_RRC_UE, RRC_DL_CCCH, message_string_size + sizeof (IttiMsgText));
      msg_p->ittiMsg.rrc_dl_ccch.size = message_string_size;
      memcpy(&msg_p->ittiMsg.rrc_dl_ccch.text, message_string, message_string_size);
734

735
      itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
736
    }
737 738
  }
# endif
739 740
#endif

741
  if ((dec_rval.code != RC_OK) && (dec_rval.consumed==0)) {
Cedric Roux's avatar
Cedric Roux committed
742
    LOG_E(RRC,"[UE %d] Frame %d : Failed to decode DL-CCCH-Message (%zu bytes)\n",ctxt_pP->module_id,ctxt_pP->frame,dec_rval.consumed);
743
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_OUT);
744
    return -1;
745 746 747 748
  }

  if (dl_ccch_msg->message.present == DL_CCCH_MessageType_PR_c1) {

749
    if (UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].State == RRC_SI_RECEIVED) {
750

751
      switch (dl_ccch_msg->message.choice.c1.present) {
752

753
      case DL_CCCH_MessageType__c1_PR_NOTHING:
754 755 756
        LOG_I(RRC, "[UE%d] Frame %d : Received PR_NOTHING on DL-CCCH-Message\n",
              ctxt_pP->module_id,
              ctxt_pP->frame);
757 758
        rval = 0;
        break;
759

760 761
      case DL_CCCH_MessageType__c1_PR_rrcConnectionReestablishment:
        LOG_I(RRC,
762 763 764
              "[UE%d] Frame %d : Logical Channel DL-CCCH (SRB0), Received RRCConnectionReestablishment\n",
              ctxt_pP->module_id,
              ctxt_pP->frame);
765 766
        rval = 0;
        break;
767

768 769
      case DL_CCCH_MessageType__c1_PR_rrcConnectionReestablishmentReject:
        LOG_I(RRC,
770 771 772
              "[UE%d] Frame %d : Logical Channel DL-CCCH (SRB0), Received RRCConnectionReestablishmentReject\n",
              ctxt_pP->module_id,
              ctxt_pP->frame);
773 774
        rval = 0;
        break;
775

776 777
      case DL_CCCH_MessageType__c1_PR_rrcConnectionReject:
        LOG_I(RRC,
778 779 780
              "[UE%d] Frame %d : Logical Channel DL-CCCH (SRB0), Received RRCConnectionReject \n",
              ctxt_pP->module_id,
              ctxt_pP->frame);
781 782
        rval = 0;
        break;
783

784 785
      case DL_CCCH_MessageType__c1_PR_rrcConnectionSetup:
        LOG_I(RRC,
786 787 788 789
              "[UE%d][RAPROC] Frame %d : Logical Channel DL-CCCH (SRB0), Received RRCConnectionSetup RNTI %x\n",
              ctxt_pP->module_id,
              ctxt_pP->frame,
              ctxt_pP->rnti);
790
        // Get configuration
791

792
        // Release T300 timer
793 794 795 796
        UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].T300_active = 0;
        rrc_ue_process_radioResourceConfigDedicated(
          ctxt_pP,
          eNB_index,
797
          &dl_ccch_msg->message.choice.c1.choice.rrcConnectionSetup.criticalExtensions.choice.c1.choice.rrcConnectionSetup_r8.radioResourceConfigDedicated);
798

799 800 801 802 803 804 805
        rrc_set_state (ctxt_pP->module_id, RRC_STATE_CONNECTED);
        rrc_set_sub_state (ctxt_pP->module_id, RRC_SUB_STATE_CONNECTED);
        UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].rnti = ctxt_pP->rnti;
        rrc_ue_generate_RRCConnectionSetupComplete(
          ctxt_pP,
          eNB_index,
          dl_ccch_msg->message.choice.c1.choice.rrcConnectionSetup.rrc_TransactionIdentifier);
806

807 808
        rval = 0;
        break;
809

810
      default:
811 812 813
        LOG_E(RRC, "[UE%d] Frame %d : Unknown message\n",
              ctxt_pP->module_id,
              ctxt_pP->frame);
814 815
        rval = -1;
        break;
816
      }
817
    }
818 819
  }

820
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_OUT);
821 822 823
  return rval;
}

824 825 826 827 828 829 830 831 832
//-----------------------------------------------------------------------------
int32_t
rrc_ue_establish_srb1(
  module_id_t ue_mod_idP,
  frame_t frameP,
  uint8_t eNB_index,
  struct SRB_ToAddMod* SRB_config
)
//-----------------------------------------------------------------------------
833
{
834
  // add descriptor from RRC PDU
835

836
  uint8_t lchan_id = DCCH;
837

Lionel Gauthier's avatar
 
Lionel Gauthier committed
838 839 840
  UE_rrc_inst[ue_mod_idP].Srb1[eNB_index].Active = 1;
  UE_rrc_inst[ue_mod_idP].Srb1[eNB_index].Status = RADIO_CONFIG_OK;//RADIO CFG
  UE_rrc_inst[ue_mod_idP].Srb1[eNB_index].Srb_info.Srb_id = 1;
841

842
  // copy default configuration for now
Lionel Gauthier's avatar
 
Lionel Gauthier committed
843 844
  //  memcpy(&UE_rrc_inst[ue_mod_idP].Srb1[eNB_index].Srb_info.Lchan_desc[0],&DCCH_LCHAN_DESC,LCHAN_DESC_SIZE);
  //  memcpy(&UE_rrc_inst[ue_mod_idP].Srb1[eNB_index].Srb_info.Lchan_desc[1],&DCCH_LCHAN_DESC,LCHAN_DESC_SIZE);
845 846


Lionel Gauthier's avatar
 
Lionel Gauthier committed
847
  LOG_I(RRC,"[UE %d], CONFIG_SRB1 %d corresponding to eNB_index %d\n", ue_mod_idP,lchan_id,eNB_index);
848

Lionel Gauthier's avatar
 
Lionel Gauthier committed
849 850
  //rrc_pdcp_config_req (ue_mod_idP+NB_eNB_INST, frameP, 0, CONFIG_ACTION_ADD, lchan_id,UNDEF_SECURITY_MODE);
  //  rrc_rlc_config_req(ue_mod_idP+NB_eNB_INST,frameP,0,CONFIG_ACTION_ADD,lchan_id,SIGNALLING_RADIO_BEARER,Rlc_info_am_config);
851

Lionel Gauthier's avatar
 
Lionel Gauthier committed
852
  //  UE_rrc_inst[ue_mod_idP].Srb1[eNB_index].Srb_info.Tx_buffer.payload_size=DEFAULT_MEAS_IND_SIZE+1;
853 854 855 856 857


  return(0);
}

858 859 860 861 862 863 864 865 866
//-----------------------------------------------------------------------------
int32_t
rrc_ue_establish_srb2(
  module_id_t ue_mod_idP,
  frame_t frameP,
  uint8_t eNB_index,
  struct SRB_ToAddMod* SRB_config
)
//-----------------------------------------------------------------------------
867
{
868
  // add descriptor from RRC PDU
869

870
  uint8_t lchan_id = DCCH1;
871

Lionel Gauthier's avatar
 
Lionel Gauthier committed
872 873 874
  UE_rrc_inst[ue_mod_idP].Srb2[eNB_index].Active = 1;
  UE_rrc_inst[ue_mod_idP].Srb2[eNB_index].Status = RADIO_CONFIG_OK;//RADIO CFG
  UE_rrc_inst[ue_mod_idP].Srb2[eNB_index].Srb_info.Srb_id = 2;
875

876
  // copy default configuration for now
Lionel Gauthier's avatar
 
Lionel Gauthier committed
877 878
  //  memcpy(&UE_rrc_inst[ue_mod_idP].Srb2[eNB_index].Srb_info.Lchan_desc[0],&DCCH_LCHAN_DESC,LCHAN_DESC_SIZE);
  //  memcpy(&UE_rrc_inst[ue_mod_idP].Srb2[eNB_index].Srb_info.Lchan_desc[1],&DCCH_LCHAN_DESC,LCHAN_DESC_SIZE);
879 880


Lionel Gauthier's avatar
 
Lionel Gauthier committed
881
  LOG_I(RRC,"[UE %d], CONFIG_SRB2 %d corresponding to eNB_index %d\n",ue_mod_idP,lchan_id,eNB_index);
882

Lionel Gauthier's avatar
 
Lionel Gauthier committed
883 884
  //rrc_pdcp_config_req (ue_mod_idP+NB_eNB_INST, frameP, 0, CONFIG_ACTION_ADD, lchan_id, UNDEF_SECURITY_MODE);
  //  rrc_rlc_config_req(ue_mod_idP+NB_eNB_INST,frameP,0,CONFIG_ACTION_ADD,lchan_id,SIGNALLING_RADIO_BEARER,Rlc_info_am_config);
885

Lionel Gauthier's avatar
 
Lionel Gauthier committed
886
  //  UE_rrc_inst[ue_mod_idP].Srb1[eNB_index].Srb_info.Tx_buffer.payload_size=DEFAULT_MEAS_IND_SIZE+1;
887 888 889 890 891


  return(0);
}

892 893 894 895 896 897 898 899 900
//-----------------------------------------------------------------------------
int32_t
rrc_ue_establish_drb(
  module_id_t ue_mod_idP,
  frame_t frameP,
  uint8_t eNB_index,
  struct DRB_ToAddMod* DRB_config
)
//-----------------------------------------------------------------------------
901
{
902 903
  // add descriptor from RRC PDU
#ifdef PDCP_USE_NETLINK
904
  int oip_ifup=0,ip_addr_offset3=0,ip_addr_offset4=0;
Cedric Roux's avatar
Cedric Roux committed
905 906 907 908
  /* avoid gcc warnings */
  (void)oip_ifup;
  (void)ip_addr_offset3;
  (void)ip_addr_offset4;
909
#endif
910

911
  LOG_I(RRC,"[UE %d] Frame %d: processing RRCConnectionReconfiguration: reconfiguring DRB %ld/LCID %d\n",
912
        ue_mod_idP, frameP, DRB_config->drb_Identity, (int)*DRB_config->logicalChannelIdentity);
913
  /*
Lionel Gauthier's avatar
 
Lionel Gauthier committed
914
  rrc_pdcp_config_req (ue_mod_idP+NB_eNB_INST, frameP, 0, CONFIG_ACTION_ADD,
915
                             (eNB_index * NB_RB_MAX) + *DRB_config->logicalChannelIdentity, UNDEF_SECURITY_MODE);
916

917
  rrc_rlc_config_req(ue_mod_idP+NB_eNB_INST,frameP,0,CONFIG_ACTION_ADD,
918 919
                    (eNB_index * NB_RB_MAX) + *DRB_config->logicalChannelIdentity,
                    RADIO_ACCESS_BEARER,Rlc_info_um);
920
   */
921
#ifdef PDCP_USE_NETLINK
922
#   if !defined(OAI_NW_DRIVER_TYPE_ETHERNET) && !defined(EXMIMO) && !defined(OAI_USRP) && !defined(OAI_BLADERF) && !defined(ETHERNET) && !defined(LINK_ENB_PDCP_TO_GTPV1U)
923
#    ifdef OAI_EMU
924 925
  ip_addr_offset3 = oai_emulation.info.nb_enb_local;
  ip_addr_offset4 = NB_eNB_INST;
926
#    else
927 928
  ip_addr_offset3 = 0;
  ip_addr_offset4 = 8;
929
#    endif
Lionel Gauthier's avatar
 
Lionel Gauthier committed
930
  LOG_I(OIP,"[UE %d] trying to bring up the OAI interface oai%d, IP 10.0.%d.%d\n", ue_mod_idP, ip_addr_offset3+ue_mod_idP,
931
        ip_addr_offset3+ue_mod_idP+1,ip_addr_offset4+ue_mod_idP+1);
Lionel Gauthier's avatar
 
Lionel Gauthier committed
932
  oip_ifup=nas_config(ip_addr_offset3+ue_mod_idP,   // interface_id
933 934 935 936
                      ip_addr_offset3+ue_mod_idP+1, // third_octet
                      ip_addr_offset4+ue_mod_idP+1); // fourth_octet

  if (oip_ifup == 0 ) { // interface is up --> send a config the DRB
937
#        ifdef OAI_EMU
938
    oai_emulation.info.oai_ifup[ue_mod_idP]=1;
939
#        endif
940
    LOG_I(OIP,"[UE %d] Config the oai%d to send/receive pkt on DRB %ld to/from the protocol stack\n",
Lionel Gauthier's avatar
 
Lionel Gauthier committed
941 942
          ue_mod_idP,
          ip_addr_offset3+ue_mod_idP,
943
          (long int)((eNB_index * maxDRB) + DRB_config->drb_Identity));
944

945 946 947 948 949 950 951 952
    rb_conf_ipv4(0,//add
                 ue_mod_idP,//cx align with the UE index
                 ip_addr_offset3+ue_mod_idP,//inst num_enb+ue_index
                 (eNB_index * maxDRB) + DRB_config->drb_Identity,//rb
                 0,//dscp
                 ipv4_address(ip_addr_offset3+ue_mod_idP+1,ip_addr_offset4+ue_mod_idP+1),//saddr
                 ipv4_address(ip_addr_offset3+ue_mod_idP+1,eNB_index+1));//daddr
    LOG_D(RRC,"[UE %d] State = Attached (eNB %d)\n",ue_mod_idP,eNB_index);
953
  }
954

955 956
#    else
#        ifdef OAI_EMU
Lionel Gauthier's avatar
 
Lionel Gauthier committed
957
  oai_emulation.info.oai_ifup[ue_mod_idP]=1;
958 959 960 961 962 963 964 965
#        endif
#    endif
#endif

  return(0);
}


966 967 968 969 970 971 972 973
//-----------------------------------------------------------------------------
void
rrc_ue_process_measConfig(
  const protocol_ctxt_t* const       ctxt_pP,
  const uint8_t                      eNB_index,
  MeasConfig_t* const               measConfig
)
//-----------------------------------------------------------------------------
974
{
975 976 977 978 979 980 981

  // This is the procedure described in 36.331 Section 5.5.2.1
  int i;
  long ind;
  MeasObjectToAddMod_t *measObj;

  if (measConfig->measObjectToRemoveList != NULL) {
982 983
    for (i=0; i<measConfig->measObjectToRemoveList->list.count; i++) {
      ind   = *measConfig->measObjectToRemoveList->list.array[i];
984
      free(UE_rrc_inst[ctxt_pP->module_id].MeasObj[eNB_index][ind-1]);
985
    }
986
  }
987

988
  if (measConfig->measObjectToAddModList != NULL) {
989 990 991 992 993 994
    LOG_D(RRC,"Measurement Object List is present\n");

    for (i=0; i<measConfig->measObjectToAddModList->list.count; i++) {
      measObj = measConfig->measObjectToAddModList->list.array[i];
      ind   = measConfig->measObjectToAddModList->list.array[i]->measObjectId;

995
      if (UE_rrc_inst[ctxt_pP->module_id].MeasObj[eNB_index][ind-1]) {
Cedric Roux's avatar
Cedric Roux committed
996
        LOG_D(RRC,"Modifying measurement object %ld\n",ind);
997
        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].MeasObj[eNB_index][ind-1],
998 999 1000
               (char*)measObj,
               sizeof(MeasObjectToAddMod_t));
      } else {
Cedric Roux's avatar
Cedric Roux committed
1001
        LOG_I(RRC,"Adding measurement object %ld\n",ind);
1002 1003

        if (measObj->measObject.present == MeasObjectToAddMod__measObject_PR_measObjectEUTRA) {
Cedric Roux's avatar
Cedric Roux committed
1004
          LOG_I(RRC,"EUTRA Measurement : carrierFreq %ld, allowedMeasBandwidth %ld,presenceAntennaPort1 %d, neighCellConfig %d\n",
1005 1006 1007 1008
                measObj->measObject.choice.measObjectEUTRA.carrierFreq,
                measObj->measObject.choice.measObjectEUTRA.allowedMeasBandwidth,
                measObj->measObject.choice.measObjectEUTRA.presenceAntennaPort1,
                measObj->measObject.choice.measObjectEUTRA.neighCellConfig.buf[0]);
1009
          UE_rrc_inst[ctxt_pP->module_id].MeasObj[eNB_index][ind-1]=measObj;
1010
        }
1011
      }
1012 1013
    }

1014
    LOG_I(RRC,"call rrc_mac_config_req \n");
1015

1016 1017 1018
    rrc_mac_config_req_ue(ctxt_pP->module_id,0,eNB_index,
			  (RadioResourceConfigCommonSIB_t *)NULL,
			  (struct PhysicalConfigDedicated *)NULL,
Cedric Roux's avatar
Cedric Roux committed
1019
#if defined(Rel10) || defined(Rel14)
1020 1021
			  (SCellToAddMod_r10_t *)NULL,
			  //struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10,
1022
#endif
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
			  UE_rrc_inst[ctxt_pP->module_id].MeasObj[eNB_index],
			  (MAC_MainConfig_t *)NULL,
			  0,
			  (struct LogicalChannelConfig *)NULL,
			  (MeasGapConfig_t *)NULL,
			  (TDD_Config_t *)NULL,
			  (MobilityControlInfo_t *)NULL,
			  NULL,
			  NULL,
			  NULL,
			  NULL,
			  NULL,
			  NULL
Cedric Roux's avatar
Cedric Roux committed
1036
#if defined(Rel10) || defined(Rel14)
1037
			  ,0,
1038 1039
			  (MBSFN_AreaInfoList_r9_t *)NULL,
			  (PMCH_InfoList_r9_t *)NULL
1040

1041 1042
#endif
#ifdef CBA
1043 1044 1045
			  ,
			  0,
			  0
1046 1047 1048
#endif
#if defined(Rel14)
           ,
1049
           0,
1050
           NULL,
1051
           NULL
1052
#endif
1053
			  );
1054
  }
1055

1056
  if (measConfig->reportConfigToRemoveList != NULL) {
1057 1058
    for (i=0; i<measConfig->reportConfigToRemoveList->list.count; i++) {
      ind   = *measConfig->reportConfigToRemoveList->list.array[i];
1059
      free(UE_rrc_inst[ctxt_pP->module_id].ReportConfig[eNB_index][ind-1]);
1060
    }
1061
  }
1062

1063
  if (measConfig->reportConfigToAddModList != NULL) {
1064 1065 1066 1067 1068
    LOG_I(RRC,"Report Configuration List is present\n");

    for (i=0; i<measConfig->reportConfigToAddModList->list.count; i++) {
      ind   = measConfig->reportConfigToAddModList->list.array[i]->reportConfigId;

1069
      if (UE_rrc_inst[ctxt_pP->module_id].ReportConfig[eNB_index][ind-1]) {
Cedric Roux's avatar
Cedric Roux committed
1070
        LOG_I(RRC,"Modifying Report Configuration %ld\n",ind-1);
1071
        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].ReportConfig[eNB_index][ind-1],
1072 1073 1074
               (char*)measConfig->reportConfigToAddModList->list.array[i],
               sizeof(ReportConfigToAddMod_t));
      } else {
Cedric Roux's avatar
Cedric Roux committed
1075
        LOG_D(RRC,"Adding Report Configuration %ld %p \n",ind-1,measConfig->reportConfigToAddModList->list.array[i]);
1076
        UE_rrc_inst[ctxt_pP->module_id].ReportConfig[eNB_index][ind-1] = measConfig->reportConfigToAddModList->list.array[i];
1077
      }
1078
    }
1079 1080 1081
  }

  if (measConfig->quantityConfig != NULL) {
1082
    if (UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index]) {
1083
      LOG_D(RRC,"Modifying Quantity Configuration \n");
1084
      memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index],
1085 1086 1087 1088
             (char*)measConfig->quantityConfig,
             sizeof(QuantityConfig_t));
    } else {
      LOG_D(RRC,"Adding Quantity configuration\n");
1089
      UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index] = measConfig->quantityConfig;
1090
    }
1091 1092 1093
  }

  if (measConfig->measIdToRemoveList != NULL) {
1094 1095
    for (i=0; i<measConfig->measIdToRemoveList->list.count; i++) {
      ind   = *measConfig->measIdToRemoveList->list.array[i];
1096
      free(UE_rrc_inst[ctxt_pP->module_id].MeasId[eNB_index][ind-1]);
1097
    }
1098 1099 1100
  }

  if (measConfig->measIdToAddModList != NULL) {
1101 1102 1103
    for (i=0; i<measConfig->measIdToAddModList->list.count; i++) {
      ind   = measConfig->measIdToAddModList->list.array[i]->measId;

1104
      if (UE_rrc_inst[ctxt_pP->module_id].MeasId[eNB_index][ind-1]) {
Cedric Roux's avatar
Cedric Roux committed
1105
        LOG_D(RRC,"Modifying Measurement ID %ld\n",ind-1);
1106
        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].MeasId[eNB_index][ind-1],
1107 1108 1109
               (char*)measConfig->measIdToAddModList->list.array[i],
               sizeof(MeasIdToAddMod_t));
      } else {
Cedric Roux's avatar
Cedric Roux committed
1110
        LOG_D(RRC,"Adding Measurement ID %ld %p\n",ind-1,measConfig->measIdToAddModList->list.array[i]);
1111
        UE_rrc_inst[ctxt_pP->module_id].MeasId[eNB_index][ind-1] = measConfig->measIdToAddModList->list.array[i];
1112
      }
1113
    }
1114 1115 1116
  }

  if (measConfig->measGapConfig !=NULL) {
1117 1118
    if (UE_rrc_inst[ctxt_pP->module_id].measGapConfig[eNB_index]) {
      memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].measGapConfig[eNB_index],
1119 1120 1121
             (char*)measConfig->measGapConfig,
             sizeof(MeasGapConfig_t));
    } else {
1122
      UE_rrc_inst[ctxt_pP->module_id].measGapConfig[eNB_index] = measConfig->measGapConfig;
1123
    }
1124 1125
  }

1126
  if (measConfig->quantityConfig != NULL) {
1127
    if (UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index]) {
1128
      LOG_I(RRC,"Modifying Quantity Configuration \n");
1129
      memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index],
1130 1131 1132 1133
             (char*)measConfig->quantityConfig,
             sizeof(QuantityConfig_t));
    } else {
      LOG_I(RRC,"Adding Quantity configuration\n");
1134
      UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index] = measConfig->quantityConfig;
1135
    }
1136

1137 1138 1139 1140
    UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrp = 1./pow(2,
        (*UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index]->quantityConfigEUTRA->filterCoefficientRSRP)/4);
    UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrq = 1./pow(2,
        (*UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index]->quantityConfigEUTRA->filterCoefficientRSRQ)/4);
1141

Cedric Roux's avatar
Cedric Roux committed
1142
    LOG_I(RRC,"[UE %d] set rsrp-coeff for eNB %d: %ld rsrq-coeff: %ld rsrp_factor: %f rsrq_factor: %f \n",
1143 1144 1145 1146 1147
          ctxt_pP->module_id, eNB_index, // UE_rrc_inst[ue_mod_idP].Info[eNB_index].UE_index,
          *UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index]->quantityConfigEUTRA->filterCoefficientRSRP,
          *UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index]->quantityConfigEUTRA->filterCoefficientRSRQ,
          UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrp,
          UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrq);
1148 1149
  }

1150
  if (measConfig->s_Measure != NULL) {
1151
    UE_rrc_inst[ctxt_pP->module_id].s_measure = *measConfig->s_Measure;
1152
  }
1153

1154
  if (measConfig->speedStatePars != NULL) {
1155 1156 1157 1158 1159
    if (UE_rrc_inst[ctxt_pP->module_id].speedStatePars) {
      memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].speedStatePars,(char*)measConfig->speedStatePars,sizeof(struct MeasConfig__speedStatePars));
    } else {
      UE_rrc_inst[ctxt_pP->module_id].speedStatePars = measConfig->speedStatePars;
    }
1160 1161

    LOG_I(RRC,"[UE %d] Configuring mobility optimization params for UE %d \n",
1162
          ctxt_pP->module_id,UE_rrc_inst[ctxt_pP->module_id].Info[0].UE_index);
1163
  }
1164 1165
}

1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178

void
rrc_ue_update_radioResourceConfigDedicated(RadioResourceConfigDedicated_t* radioResourceConfigDedicated,
        const protocol_ctxt_t* const ctxt_pP,
        uint8_t eNB_index)
{
    PhysicalConfigDedicated_t* physicalConfigDedicated2 = NULL;

    physicalConfigDedicated2 = CALLOC(1,sizeof(*physicalConfigDedicated2));
    physicalConfigDedicated2->pdsch_ConfigDedicated         = CALLOC(1,sizeof(*physicalConfigDedicated2->pdsch_ConfigDedicated));
    physicalConfigDedicated2->pusch_ConfigDedicated         = CALLOC(1,sizeof(*physicalConfigDedicated2->pusch_ConfigDedicated));
    physicalConfigDedicated2->pucch_ConfigDedicated         = CALLOC(1,sizeof(*physicalConfigDedicated2->pucch_ConfigDedicated));
    physicalConfigDedicated2->cqi_ReportConfig              = CALLOC(1,sizeof(*physicalConfigDedicated2->cqi_ReportConfig));
1179 1180
    physicalConfigDedicated2->cqi_ReportConfig->cqi_ReportPeriodic
                                                            = CALLOC(1,sizeof(*physicalConfigDedicated2->cqi_ReportConfig->cqi_ReportPeriodic));
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
    physicalConfigDedicated2->soundingRS_UL_ConfigDedicated = CALLOC(1,sizeof(*physicalConfigDedicated2->soundingRS_UL_ConfigDedicated));
    physicalConfigDedicated2->schedulingRequestConfig       = CALLOC(1,sizeof(*physicalConfigDedicated2->schedulingRequestConfig));
    physicalConfigDedicated2->antennaInfo                   = CALLOC(1,sizeof(*physicalConfigDedicated2->antennaInfo));

    physicalConfigDedicated2->uplinkPowerControlDedicated   = CALLOC(1,sizeof(*physicalConfigDedicated2->uplinkPowerControlDedicated));
    physicalConfigDedicated2->tpc_PDCCH_ConfigPUSCH         = CALLOC(1,sizeof(*physicalConfigDedicated2->tpc_PDCCH_ConfigPUSCH));
    physicalConfigDedicated2->tpc_PDCCH_ConfigPUCCH         = CALLOC(1,sizeof(*physicalConfigDedicated2->tpc_PDCCH_ConfigPUCCH));

    // Update pdsch_ConfigDedicated
    if(radioResourceConfigDedicated->physicalConfigDedicated->pdsch_ConfigDedicated != NULL)
    {
        LOG_I(RRC,"Update pdsch_ConfigDedicated config \n");

        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->pdsch_ConfigDedicated == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->pdsch_ConfigDedicated = CALLOC(1,sizeof(PDSCH_ConfigDedicated_t));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->pdsch_ConfigDedicated,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->pdsch_ConfigDedicated,
                sizeof(physicalConfigDedicated2->pdsch_ConfigDedicated));
    }
    else
    {
        LOG_I(RRC,"Keep old config for pdsch_ConfigDedicated\n");
    }

    // Update pusch_ConfigDedicated
    if(radioResourceConfigDedicated->physicalConfigDedicated->pusch_ConfigDedicated != NULL)
    {
        LOG_I(RRC,"Update pusch_ConfigDedicated config \n");

        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->pusch_ConfigDedicated == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->pusch_ConfigDedicated = CALLOC(1,sizeof(PUSCH_ConfigDedicated_t));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->pusch_ConfigDedicated,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->pusch_ConfigDedicated,
                sizeof(physicalConfigDedicated2->pusch_ConfigDedicated));
    }
    else
    {
        LOG_I(RRC,"Keep old config for pusch_ConfigDedicated\n");
    }

    // Update pucch_ConfigDedicated
    if(radioResourceConfigDedicated->physicalConfigDedicated->pucch_ConfigDedicated != NULL)
    {
        LOG_I(RRC,"Update pucch_ConfigDedicated config \n");
        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->pucch_ConfigDedicated == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->pucch_ConfigDedicated = CALLOC(1,sizeof(PUCCH_ConfigDedicated_t));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->pucch_ConfigDedicated,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->pucch_ConfigDedicated,
                sizeof(physicalConfigDedicated2->pucch_ConfigDedicated));
    }
    else
    {
        LOG_I(RRC,"Keep old config for pucch_ConfigDedicated\n");
    }

    // Update cqi_ReportConfig
    if(radioResourceConfigDedicated->physicalConfigDedicated->cqi_ReportConfig != NULL)
    {
Cedric Roux's avatar
Cedric Roux committed
1242
        LOG_I(RRC,"Update cqi_ReportConfig config (size=%zu,%zu)\n", sizeof(*physicalConfigDedicated2->cqi_ReportConfig), sizeof(CQI_ReportConfig_t));
1243 1244 1245 1246 1247 1248

        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->cqi_ReportConfig == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->cqi_ReportConfig = CALLOC(1,sizeof(CQI_ReportConfig_t));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->cqi_ReportConfig,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->cqi_ReportConfig,
1249 1250 1251
                sizeof(*physicalConfigDedicated2->cqi_ReportConfig));

        if (radioResourceConfigDedicated->physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic != NULL) {
Cedric Roux's avatar
Cedric Roux committed
1252
          LOG_I(RRC,"Update cqi_ReportPeriodic config (size=%zu,%zu)\n", sizeof(*physicalConfigDedicated2->cqi_ReportConfig->cqi_ReportPeriodic), sizeof(CQI_ReportPeriodic_t));
1253 1254 1255 1256 1257 1258 1259 1260

          if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->cqi_ReportConfig->cqi_ReportPeriodic == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->cqi_ReportConfig->cqi_ReportPeriodic = CALLOC(1,sizeof(CQI_ReportPeriodic_t));

          memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->cqi_ReportConfig->cqi_ReportPeriodic,
                  (char*)radioResourceConfigDedicated->physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic,
                  sizeof(*physicalConfigDedicated2->cqi_ReportConfig->cqi_ReportPeriodic));
        }
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
    }
    else
    {
        LOG_I(RRC,"Keep old config for cqi_ReportConfig\n");
    }

    // Update schedulingRequestConfig
    if(radioResourceConfigDedicated->physicalConfigDedicated->schedulingRequestConfig != NULL)
    {
        LOG_I(RRC,"Update schedulingRequestConfig config \n");

        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->schedulingRequestConfig == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->schedulingRequestConfig = CALLOC(1,sizeof(SchedulingRequestConfig_t));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->schedulingRequestConfig,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->schedulingRequestConfig,
                sizeof(physicalConfigDedicated2->schedulingRequestConfig));
    }
    else
    {
        LOG_I(RRC,"Keep old config for schedulingRequestConfig\n");
    }

    // Update soundingRS_UL_ConfigDedicated
    if(radioResourceConfigDedicated->physicalConfigDedicated->soundingRS_UL_ConfigDedicated != NULL)
    {
        LOG_I(RRC,"Update soundingRS_UL_ConfigDedicated config \n");

        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->soundingRS_UL_ConfigDedicated == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->soundingRS_UL_ConfigDedicated = CALLOC(1,sizeof(SoundingRS_UL_ConfigDedicated_t));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->soundingRS_UL_ConfigDedicated,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->soundingRS_UL_ConfigDedicated,
                sizeof(physicalConfigDedicated2->soundingRS_UL_ConfigDedicated));
    }
    else
    {
        LOG_I(RRC,"Keep old config for soundingRS_UL_ConfigDedicated\n");
    }

    // Update antennaInfo
    if(radioResourceConfigDedicated->physicalConfigDedicated->antennaInfo != NULL)
    {
        LOG_I(RRC,"Update antennaInfo config \n");

        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->antennaInfo == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->antennaInfo = CALLOC(1,sizeof(struct PhysicalConfigDedicated__antennaInfo));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->antennaInfo,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->antennaInfo,
                sizeof(physicalConfigDedicated2->antennaInfo));
1312 1313 1314 1315 1316 1317 1318 1319

        UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->antennaInfo->choice.explicitValue.transmissionMode =
        		radioResourceConfigDedicated->physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode;
        UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->antennaInfo->choice.explicitValue.codebookSubsetRestriction =
        		radioResourceConfigDedicated->physicalConfigDedicated->antennaInfo->choice.explicitValue.codebookSubsetRestriction;
        UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->antennaInfo->choice.explicitValue.ue_TransmitAntennaSelection =
        		radioResourceConfigDedicated->physicalConfigDedicated->antennaInfo->choice.explicitValue.ue_TransmitAntennaSelection;

1320 1321
        LOG_I(PHY,"New Transmission Mode %ld \n",radioResourceConfigDedicated->physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode);
        LOG_I(PHY,"Configured Transmission Mode %ld \n",UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->antennaInfo->choice.explicitValue.transmissionMode);
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 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
    }
    else
    {
        LOG_I(RRC,"Keep old config for antennaInfo\n");
    }


    // Update uplinkPowerControlDedicated
    if(radioResourceConfigDedicated->physicalConfigDedicated->uplinkPowerControlDedicated != NULL)
    {
        LOG_I(RRC,"Update uplinkPowerControlDedicated config \n");

        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->uplinkPowerControlDedicated == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->uplinkPowerControlDedicated = CALLOC(1,sizeof(UplinkPowerControlDedicated_t));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->uplinkPowerControlDedicated,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->uplinkPowerControlDedicated,
                sizeof(physicalConfigDedicated2->uplinkPowerControlDedicated));
    }
    else
    {
        LOG_I(RRC,"Keep old config for uplinkPowerControlDedicated\n");
    }

    // Update tpc_PDCCH_ConfigPUCCH
    if(radioResourceConfigDedicated->physicalConfigDedicated->tpc_PDCCH_ConfigPUCCH != NULL)
    {
        LOG_I(RRC,"Update tpc_PDCCH_ConfigPUCCH config \n");

        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->tpc_PDCCH_ConfigPUCCH == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->tpc_PDCCH_ConfigPUCCH = CALLOC(1,sizeof(TPC_PDCCH_Config_t));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->tpc_PDCCH_ConfigPUCCH,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->tpc_PDCCH_ConfigPUCCH,
                sizeof(physicalConfigDedicated2->tpc_PDCCH_ConfigPUCCH));
    }
    else
    {
        LOG_I(RRC,"Keep old config for tpc_PDCCH_ConfigPUCCH\n");
    }

    // Update tpc_PDCCH_ConfigPUSCH
    if(radioResourceConfigDedicated->physicalConfigDedicated->tpc_PDCCH_ConfigPUSCH != NULL)
    {
        LOG_I(RRC,"Update tpc_PDCCH_ConfigPUSCH config \n");

        if(UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->tpc_PDCCH_ConfigPUSCH == NULL)
            UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->tpc_PDCCH_ConfigPUSCH = CALLOC(1,sizeof(TPC_PDCCH_Config_t));

        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]->tpc_PDCCH_ConfigPUSCH,
                (char*)radioResourceConfigDedicated->physicalConfigDedicated->tpc_PDCCH_ConfigPUSCH,
                sizeof(physicalConfigDedicated2->tpc_PDCCH_ConfigPUSCH));

    }
    else
    {
        LOG_I(RRC,"Keep old config for tpc_PDCCH_ConfigPUSCH\n");
    }

}
1383
//-----------------------------------------------------------------------------
1384
void
1385 1386 1387 1388 1389 1390
rrc_ue_process_radioResourceConfigDedicated(
  const protocol_ctxt_t* const ctxt_pP,
  uint8_t eNB_index,
  RadioResourceConfigDedicated_t* radioResourceConfigDedicated
)
//-----------------------------------------------------------------------------
1391
{
1392 1393 1394 1395

  long SRB_id,DRB_id;
  int i,cnt;
  LogicalChannelConfig_t *SRB1_logicalChannelConfig,*SRB2_logicalChannelConfig;
1396
#ifdef CBA
1397 1398
  uint8_t cba_found = 0;
  uint16_t cba_RNTI;
1399
#endif
1400 1401 1402

  // Save physicalConfigDedicated if present
  if (radioResourceConfigDedicated->physicalConfigDedicated) {
1403 1404
    LOG_I(RRC,"Save physicalConfigDedicated if present \n");

1405
    if (UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index]) {
1406 1407 1408
#if 1
        rrc_ue_update_radioResourceConfigDedicated(radioResourceConfigDedicated, ctxt_pP, eNB_index);
#else
1409
      memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index],(char*)radioResourceConfigDedicated->physicalConfigDedicated,
1410
             sizeof(struct PhysicalConfigDedicated));
1411
#endif
1412
    } else {
1413
      LOG_I(RRC,"Init physicalConfigDedicated UE_rrc_inst to radioResourceConfigDedicated->physicalConfigDedicated\n");
1414
      UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index] = radioResourceConfigDedicated->physicalConfigDedicated;
1415
    }
1416
  }
1417

1418 1419
  // Apply macMainConfig if present
  if (radioResourceConfigDedicated->mac_MainConfig) {
1420
    if (radioResourceConfigDedicated->mac_MainConfig->present == RadioResourceConfigDedicated__mac_MainConfig_PR_explicitValue) {
1421 1422
      if (UE_rrc_inst[ctxt_pP->module_id].mac_MainConfig[eNB_index]) {
        memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].mac_MainConfig[eNB_index],(char*)&radioResourceConfigDedicated->mac_MainConfig->choice.explicitValue,
1423
               sizeof(MAC_MainConfig_t));
1424 1425 1426
      } else {
        UE_rrc_inst[ctxt_pP->module_id].mac_MainConfig[eNB_index] = &radioResourceConfigDedicated->mac_MainConfig->choice.explicitValue;
      }
1427
    }
1428 1429 1430 1431
  }

  // Apply spsConfig if present
  if (radioResourceConfigDedicated->sps_Config) {
1432 1433
    if (UE_rrc_inst[ctxt_pP->module_id].sps_Config[eNB_index]) {
      memcpy(UE_rrc_inst[ctxt_pP->module_id].sps_Config[eNB_index],radioResourceConfigDedicated->sps_Config,
1434 1435
             sizeof(struct SPS_Config));
    } else {
1436
      UE_rrc_inst[ctxt_pP->module_id].sps_Config[eNB_index] = radioResourceConfigDedicated->sps_Config;
1437
    }
1438
  }
1439

1440
#ifdef CBA
1441

1442
  if (radioResourceConfigDedicated->cba_RNTI_vlola) {
1443 1444 1445 1446
    cba_RNTI = (uint16_t) (((radioResourceConfigDedicated->cba_RNTI_vlola->buf[1]&0xff) << 8) |
                           (radioResourceConfigDedicated->cba_RNTI_vlola->buf[0]&0xff));

    for (i=0 ; i< NUM_MAX_CBA_GROUP; i++) {
1447
      if (UE_rrc_inst[ctxt_pP->module_id].cba_rnti[i] == cba_RNTI ) {
1448 1449
        cba_found=1;
        break;
1450
      } else if (UE_rrc_inst[ctxt_pP->module_id].cba_rnti[i] == 0 ) {
1451
        break;
1452
      }
1453 1454 1455
    }

    if (cba_found==0) {
1456 1457
      UE_rrc_inst[ctxt_pP->module_id].num_active_cba_groups++;
      UE_rrc_inst[ctxt_pP->module_id].cba_rnti[i]=cba_RNTI;
1458
      LOG_D(RRC, "[UE %d] Frame %d: radioResourceConfigDedicated reveived CBA_RNTI = %x for group %d from eNB %d \n",
1459
            ctxt_pP->module_id,frameP, UE_rrc_inst[ctxt_pP->module_id].cba_rnti[i], i, eNB_index);
1460
    }
1461
  }
1462 1463 1464

#endif

1465 1466 1467
  // Establish SRBs if present
  // loop through SRBToAddModList
  if (radioResourceConfigDedicated->srb_ToAddModList) {
1468 1469
    uint8_t *kRRCenc = NULL;
    uint8_t *kRRCint = NULL;
1470 1471

#if defined(ENABLE_SECURITY)
1472 1473 1474 1475
    derive_key_rrc_enc(UE_rrc_inst[ctxt_pP->module_id].ciphering_algorithm,
                       UE_rrc_inst[ctxt_pP->module_id].kenb, &kRRCenc);
    derive_key_rrc_int(UE_rrc_inst[ctxt_pP->module_id].integrity_algorithm,
                       UE_rrc_inst[ctxt_pP->module_id].kenb, &kRRCint);
1476 1477
#endif
    // Refresh SRBs
1478
    rrc_pdcp_config_asn1_req(ctxt_pP,
1479 1480 1481
                             radioResourceConfigDedicated->srb_ToAddModList,
                             (DRB_ToAddModList_t*)NULL,
                             (DRB_ToReleaseList_t*)NULL,
1482 1483
                             UE_rrc_inst[ctxt_pP->module_id].ciphering_algorithm |
                             (UE_rrc_inst[ctxt_pP->module_id].integrity_algorithm << 4),
1484 1485 1486
                             kRRCenc,
                             kRRCint,
                             NULL
Cedric Roux's avatar
Cedric Roux committed
1487
#if defined(Rel10) || defined(Rel14)
1488
                             ,(PMCH_InfoList_r9_t *)NULL
1489
#endif
1490
                             ,NULL);
1491

1492
    // Refresh SRBs
1493
    rrc_rlc_config_asn1_req(ctxt_pP,
1494 1495 1496
                            radioResourceConfigDedicated->srb_ToAddModList,
                            (DRB_ToAddModList_t*)NULL,
                            (DRB_ToReleaseList_t*)NULL
Cedric Roux's avatar
Cedric Roux committed
1497
#if defined(Rel10) || defined(Rel14)
1498
                            ,(PMCH_InfoList_r9_t *)NULL
1499
                            , 0, 0
1500
#endif
1501
                           );
1502

1503
#if ENABLE_RAL
1504
    // first msg that includes srb config
1505
    UE_rrc_inst[ctxt_pP->module_id].num_srb=radioResourceConfigDedicated->srb_ToAddModList->list.count;
1506
#endif
1507

1508 1509 1510
    for (cnt=0; cnt<radioResourceConfigDedicated->srb_ToAddModList->list.count; cnt++) {
      //  connection_reestablishment_ind.num_srb+=1;
      SRB_id = radioResourceConfigDedicated->srb_ToAddModList->list.array[cnt]->srb_Identity;
1511
      LOG_D(RRC,"[UE %d]: Frame %d SRB config cnt %d (SRB%ld)\n",ctxt_pP->module_id,ctxt_pP->frame,cnt,SRB_id);
1512 1513

      if (SRB_id == 1) {
1514 1515
        if (UE_rrc_inst[ctxt_pP->module_id].SRB1_config[eNB_index]) {
          memcpy(UE_rrc_inst[ctxt_pP->module_id].SRB1_config[eNB_index],radioResourceConfigDedicated->srb_ToAddModList->list.array[cnt],
1516 1517
                 sizeof(struct SRB_ToAddMod));
        } else {
1518 1519
          UE_rrc_inst[ctxt_pP->module_id].SRB1_config[eNB_index] = radioResourceConfigDedicated->srb_ToAddModList->list.array[cnt];
          rrc_ue_establish_srb1(ctxt_pP->module_id,ctxt_pP->frame,eNB_index,radioResourceConfigDedicated->srb_ToAddModList->list.array[cnt]);
1520

1521 1522 1523
          if (UE_rrc_inst[ctxt_pP->module_id].SRB1_config[eNB_index]->logicalChannelConfig) {
            if (UE_rrc_inst[ctxt_pP->module_id].SRB1_config[eNB_index]->logicalChannelConfig->present == SRB_ToAddMod__logicalChannelConfig_PR_explicitValue) {
              SRB1_logicalChannelConfig = &UE_rrc_inst[ctxt_pP->module_id].SRB1_config[eNB_index]->logicalChannelConfig->choice.explicitValue;
1524 1525 1526 1527 1528 1529 1530 1531

            } else {
              SRB1_logicalChannelConfig = &SRB1_logicalChannelConfig_defaultValue;
            }
          } else {
            SRB1_logicalChannelConfig = &SRB1_logicalChannelConfig_defaultValue;
          }

1532
          LOG_I(RRC, "[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ  (SRB1 eNB %d) --->][MAC_UE][MOD %02d][]\n",
1533
                ctxt_pP->frame, ctxt_pP->module_id, eNB_index, ctxt_pP->module_id);
1534

1535 1536 1537
          rrc_mac_config_req_ue(ctxt_pP->module_id,0,eNB_index,
				(RadioResourceConfigCommonSIB_t *)NULL,
				UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index],
Cedric Roux's avatar
Cedric Roux committed
1538
#if defined(Rel10) || defined(Rel14)
1539 1540
				(SCellToAddMod_r10_t *)NULL,
				//struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10,
1541
#endif
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554
				(MeasObjectToAddMod_t **)NULL,
				UE_rrc_inst[ctxt_pP->module_id].mac_MainConfig[eNB_index],
				1,
				SRB1_logicalChannelConfig,
				(MeasGapConfig_t *)NULL,
				NULL,
				NULL,
				NULL,
				NULL,
				NULL,
				NULL,
				NULL,
				NULL
Cedric Roux's avatar
Cedric Roux committed
1555
#if defined(Rel10) || defined(Rel14)
1556 1557 1558 1559
				,
				0,
				(MBSFN_AreaInfoList_r9_t *)NULL,
				(PMCH_InfoList_r9_t *)NULL
1560 1561
#endif
#ifdef CBA
1562 1563 1564
				,
				0,
				0
1565 1566 1567
#endif
#if defined(Rel14)
           ,
1568
           0,
1569
           NULL,
1570
           NULL
1571
#endif
1572
				);
1573 1574
        }
      } else {
1575 1576
        if (UE_rrc_inst[ctxt_pP->module_id].SRB2_config[eNB_index]) {
          memcpy(UE_rrc_inst[ctxt_pP->module_id].SRB2_config[eNB_index],radioResourceConfigDedicated->srb_ToAddModList->list.array[cnt],
1577 1578
                 sizeof(struct SRB_ToAddMod));
        } else {
1579 1580
          UE_rrc_inst[ctxt_pP->module_id].SRB2_config[eNB_index] = radioResourceConfigDedicated->srb_ToAddModList->list.array[cnt];
          rrc_ue_establish_srb2(ctxt_pP->module_id,ctxt_pP->frame,eNB_index,radioResourceConfigDedicated->srb_ToAddModList->list.array[cnt]);
1581

1582 1583
          if (UE_rrc_inst[ctxt_pP->module_id].SRB2_config[eNB_index]->logicalChannelConfig) {
            if (UE_rrc_inst[ctxt_pP->module_id].SRB2_config[eNB_index]->logicalChannelConfig->present == SRB_ToAddMod__logicalChannelConfig_PR_explicitValue) {
1584
              LOG_I(RRC,"Applying Explicit SRB2 logicalChannelConfig\n");
1585
              SRB2_logicalChannelConfig = &UE_rrc_inst[ctxt_pP->module_id].SRB2_config[eNB_index]->logicalChannelConfig->choice.explicitValue;
1586 1587 1588 1589 1590 1591
            } else {
              LOG_I(RRC,"Applying default SRB2 logicalChannelConfig\n");
              SRB2_logicalChannelConfig = &SRB2_logicalChannelConfig_defaultValue;
            }
          } else {
            SRB2_logicalChannelConfig = &SRB2_logicalChannelConfig_defaultValue;
1592
          }
1593

1594
          LOG_I(RRC, "[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ  (SRB2 eNB %d) --->][MAC_UE][MOD %02d][]\n",
1595 1596 1597 1598
                ctxt_pP->frame,
                ctxt_pP->module_id,
                eNB_index,
                ctxt_pP->module_id);
1599 1600 1601
          rrc_mac_config_req_ue(ctxt_pP->module_id,0,eNB_index,
				(RadioResourceConfigCommonSIB_t *)NULL,
				UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index],
Cedric Roux's avatar
Cedric Roux committed
1602
#if defined(Rel10) || defined(Rel14)
1603 1604
				(SCellToAddMod_r10_t *)NULL,
				//struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10,
1605
#endif
1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
				(MeasObjectToAddMod_t **)NULL,
				UE_rrc_inst[ctxt_pP->module_id].mac_MainConfig[eNB_index],
				2,
				SRB2_logicalChannelConfig,
				UE_rrc_inst[ctxt_pP->module_id].measGapConfig[eNB_index],
				(TDD_Config_t *)NULL,
				(MobilityControlInfo_t *)NULL,
				NULL,
				NULL,
				NULL,
				NULL,
				NULL,
				NULL
Cedric Roux's avatar
Cedric Roux committed
1619
#if defined(Rel10) || defined(Rel14)
1620 1621 1622 1623
				,
				0,
				(MBSFN_AreaInfoList_r9_t *)NULL,
				(PMCH_InfoList_r9_t *)NULL
1624

1625 1626
#endif
#ifdef CBA
1627 1628 1629
				,
				0,
				0
1630 1631 1632
#endif
#if defined(Rel14)
           ,
1633
           0,
1634
           NULL,
1635
           NULL
1636
#endif
1637
				);
1638
        }
1639
      }
1640
    }
1641 1642 1643 1644
  }

  // Establish DRBs if present
  if (radioResourceConfigDedicated->drb_ToAddModList) {
1645 1646 1647 1648 1649 1650 1651 1652 1653

    if ( (UE_rrc_inst[ctxt_pP->module_id].defaultDRB == NULL) &&
         (radioResourceConfigDedicated->drb_ToAddModList->list.count >= 1) ) {
        // configure the first DRB ID as the default DRB ID
        UE_rrc_inst[ctxt_pP->module_id].defaultDRB = malloc(sizeof(rb_id_t));
        *UE_rrc_inst[ctxt_pP->module_id].defaultDRB = radioResourceConfigDedicated->drb_ToAddModList->list.array[0]->drb_Identity;
        LOG_I(RRC,"[UE %d] default DRB = %d\n",ctxt_pP->module_id, *UE_rrc_inst[ctxt_pP->module_id].defaultDRB);
      }

1654
    uint8_t *kUPenc = NULL;
1655 1656

#if defined(ENABLE_SECURITY)
1657 1658
    derive_key_up_enc(UE_rrc_inst[ctxt_pP->module_id].integrity_algorithm,
                      UE_rrc_inst[ctxt_pP->module_id].kenb, &kUPenc);
1659 1660
#endif

Lionel Gauthier's avatar
Lionel Gauthier committed
1661 1662 1663 1664 1665 1666 1667 1668 1669
    MSC_LOG_TX_MESSAGE(
      MSC_RRC_UE,
      MSC_PDCP_UE,
      NULL,
      0,
      MSC_AS_TIME_FMT" CONFIG_REQ UE %x DRB (security %X)",
      MSC_AS_TIME_ARGS(ctxt_pP),
      ctxt_pP->rnti,
      UE_rrc_inst[ctxt_pP->module_id].ciphering_algorithm |
1670
      (UE_rrc_inst[ctxt_pP->module_id].integrity_algorithm << 4));
Lionel Gauthier's avatar
Lionel Gauthier committed
1671

1672
    // Refresh DRBs
1673
    rrc_pdcp_config_asn1_req(ctxt_pP,
1674 1675 1676
                             (SRB_ToAddModList_t*)NULL,
                             radioResourceConfigDedicated->drb_ToAddModList,
                             (DRB_ToReleaseList_t*)NULL,
1677 1678
                             UE_rrc_inst[ctxt_pP->module_id].ciphering_algorithm |
                             (UE_rrc_inst[ctxt_pP->module_id].integrity_algorithm << 4),
1679 1680 1681
                             NULL,
                             NULL,
                             kUPenc
Cedric Roux's avatar
Cedric Roux committed
1682
#if defined(Rel10) || defined(Rel14)
1683
                             ,(PMCH_InfoList_r9_t *)NULL
1684
#endif
1685
                             , UE_rrc_inst[ctxt_pP->module_id].defaultDRB);
1686

1687
    // Refresh DRBs
1688
    rrc_rlc_config_asn1_req(ctxt_pP,
1689 1690 1691
                            (SRB_ToAddModList_t*)NULL,
                            radioResourceConfigDedicated->drb_ToAddModList,
                            (DRB_ToReleaseList_t*)NULL
Cedric Roux's avatar
Cedric Roux committed
1692
#if defined(Rel10) || defined(Rel14)
1693
                            ,(PMCH_InfoList_r9_t *)NULL
1694
                            , 0, 0
1695 1696 1697 1698 1699 1700
#endif
                           );

    for (i=0; i<radioResourceConfigDedicated->drb_ToAddModList->list.count; i++) {
      DRB_id   = radioResourceConfigDedicated->drb_ToAddModList->list.array[i]->drb_Identity-1;

1701 1702 1703
      if (UE_rrc_inst[ctxt_pP->module_id].DRB_config[eNB_index][DRB_id]) {
        memcpy(UE_rrc_inst[ctxt_pP->module_id].DRB_config[eNB_index][DRB_id],
               radioResourceConfigDedicated->drb_ToAddModList->list.array[i],
1704 1705
               sizeof(struct DRB_ToAddMod));
      } else {
1706 1707
        UE_rrc_inst[ctxt_pP->module_id].DRB_config[eNB_index][DRB_id] = radioResourceConfigDedicated->drb_ToAddModList->list.array[i];
        rrc_ue_establish_drb(ctxt_pP->module_id,ctxt_pP->frame,eNB_index,radioResourceConfigDedicated->drb_ToAddModList->list.array[i]);
1708
        // MAC/PHY Configuration
Cedric Roux's avatar
Cedric Roux committed
1709
        LOG_I(RRC, "[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ (DRB %ld eNB %d) --->][MAC_UE][MOD %02d][]\n",
1710 1711 1712 1713
              ctxt_pP->frame, ctxt_pP->module_id,
              radioResourceConfigDedicated->drb_ToAddModList->list.array[i]->drb_Identity,
              eNB_index,
              ctxt_pP->module_id);
1714 1715 1716
        rrc_mac_config_req_ue(ctxt_pP->module_id,0,eNB_index,
			      (RadioResourceConfigCommonSIB_t *)NULL,
			      UE_rrc_inst[ctxt_pP->module_id].physicalConfigDedicated[eNB_index],
Cedric Roux's avatar
Cedric Roux committed
1717
#if defined(Rel10) || defined(Rel14)
1718 1719
			      (SCellToAddMod_r10_t *)NULL,
			      //struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10,
1720
#endif
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
			      (MeasObjectToAddMod_t **)NULL,
			      UE_rrc_inst[ctxt_pP->module_id].mac_MainConfig[eNB_index],
			      *UE_rrc_inst[ctxt_pP->module_id].DRB_config[eNB_index][DRB_id]->logicalChannelIdentity,
			      UE_rrc_inst[ctxt_pP->module_id].DRB_config[eNB_index][DRB_id]->logicalChannelConfig,
			      UE_rrc_inst[ctxt_pP->module_id].measGapConfig[eNB_index],
			      (TDD_Config_t*)NULL,
			      (MobilityControlInfo_t *)NULL,
			      NULL,
			      NULL,
			      NULL,
			      NULL,
			      NULL,
			      NULL
Cedric Roux's avatar
Cedric Roux committed
1734
#if defined(Rel10) || defined(Rel14)
1735 1736 1737 1738
			      ,
			      0,
			      (MBSFN_AreaInfoList_r9_t *)NULL,
			      (PMCH_InfoList_r9_t *)NULL
1739 1740
#endif
#ifdef CBA
1741 1742 1743
			      ,
			      UE_rrc_inst[ue_mod_idP].num_active_cba_groups, //
			      UE_rrc_inst[ue_mod_idP].cba_rnti[0]
1744 1745 1746
#endif
#if defined(Rel14)
           ,
1747
           0,
1748
           NULL,
1749
           NULL
1750
#endif
1751
			      );
1752

1753
      }
1754
    }
1755
  }
1756

1757 1758
  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].State = RRC_CONNECTED;
  LOG_I(RRC,"[UE %d] State = RRC_CONNECTED (eNB %d)\n",ctxt_pP->module_id,eNB_index);
1759
#if !defined(ENABLE_USE_MME) && defined(OAI_EMU)
Raymond Knopp's avatar
 
Raymond Knopp committed
1760
#    ifdef OAI_EMU
1761 1762 1763 1764 1765 1766 1767
  rrc_eNB_emulation_notify_ue_module_id(
    ctxt_pP->module_id,
    ctxt_pP->rnti,
    UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index]->cellAccessRelatedInfo.cellIdentity.buf[0],
    UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index]->cellAccessRelatedInfo.cellIdentity.buf[1],
    UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index]->cellAccessRelatedInfo.cellIdentity.buf[2],
    UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index]->cellAccessRelatedInfo.cellIdentity.buf[3]);
Cedric Roux's avatar
Cedric Roux committed
1768
#    endif /* OAI_EMU */
1769
#endif
1770 1771
}

1772 1773 1774 1775 1776 1777 1778 1779 1780

//-----------------------------------------------------------------------------
void
rrc_ue_process_securityModeCommand(
  const protocol_ctxt_t* const ctxt_pP,
  SecurityModeCommand_t* const securityModeCommand,
  const uint8_t                eNB_index
)
//-----------------------------------------------------------------------------
1781
{
1782 1783 1784 1785 1786 1787 1788

  asn_enc_rval_t enc_rval;

  UL_DCCH_Message_t ul_dcch_msg;
  // SecurityModeCommand_t SecurityModeCommand;
  uint8_t buffer[200];
  int i, securityMode;
1789

1790
  LOG_I(RRC,"[UE %d] Frame %d: Receiving from SRB1 (DL-DCCH), Processing securityModeCommand (eNB %d)\n",
1791
        ctxt_pP->module_id,ctxt_pP->frame,eNB_index);
1792

1793
  switch (securityModeCommand->criticalExtensions.choice.c1.choice.securityModeCommand_r8.securityConfigSMC.securityAlgorithmConfig.cipheringAlgorithm) {
Cedric Roux's avatar
Cedric Roux committed
1794
  case CipheringAlgorithm_r12_eea0:
1795 1796
    LOG_I(RRC,"[UE %d] Security algorithm is set to eea0\n",
          ctxt_pP->module_id);
Cedric Roux's avatar
Cedric Roux committed
1797
    securityMode= CipheringAlgorithm_r12_eea0;
1798
    break;
1799

Cedric Roux's avatar
Cedric Roux committed
1800
  case CipheringAlgorithm_r12_eea1:
1801
    LOG_I(RRC,"[UE %d] Security algorithm is set to eea1\n",ctxt_pP->module_id);
Cedric Roux's avatar
Cedric Roux committed
1802
    securityMode= CipheringAlgorithm_r12_eea1;
1803
    break;
1804

Cedric Roux's avatar
Cedric Roux committed
1805
  case CipheringAlgorithm_r12_eea2:
1806 1807
    LOG_I(RRC,"[UE %d] Security algorithm is set to eea2\n",
          ctxt_pP->module_id);
Cedric Roux's avatar
Cedric Roux committed
1808
    securityMode = CipheringAlgorithm_r12_eea2;
1809
    break;
1810

1811
  default:
1812
    LOG_I(RRC,"[UE %d] Security algorithm is set to none\n",ctxt_pP->module_id);
Cedric Roux's avatar
Cedric Roux committed
1813
    securityMode = CipheringAlgorithm_r12_spare1;
1814 1815
    break;
  }
1816 1817

  switch (securityModeCommand->criticalExtensions.choice.c1.choice.securityModeCommand_r8.securityConfigSMC.securityAlgorithmConfig.integrityProtAlgorithm) {
1818
  case SecurityAlgorithmConfig__integrityProtAlgorithm_eia1:
1819
    LOG_I(RRC,"[UE %d] Integrity protection algorithm is set to eia1\n",ctxt_pP->module_id);
1820 1821
    securityMode |= 1 << 5;
    break;
1822

1823
  case SecurityAlgorithmConfig__integrityProtAlgorithm_eia2:
1824
    LOG_I(RRC,"[UE %d] Integrity protection algorithm is set to eia2\n",ctxt_pP->module_id);
1825 1826
    securityMode |= 1 << 6;
    break;
1827

1828
  default:
1829
    LOG_I(RRC,"[UE %d] Integrity protection algorithm is set to none\n",ctxt_pP->module_id);
1830 1831 1832
    securityMode |= 0x70 ;
    break;
  }
1833

1834
  LOG_D(RRC,"[UE %d] security mode is %x \n",ctxt_pP->module_id, securityMode);
1835 1836

  /* Store the parameters received */
1837 1838 1839 1840
  UE_rrc_inst[ctxt_pP->module_id].ciphering_algorithm =
    securityModeCommand->criticalExtensions.choice.c1.choice.securityModeCommand_r8.securityConfigSMC.securityAlgorithmConfig.cipheringAlgorithm;
  UE_rrc_inst[ctxt_pP->module_id].integrity_algorithm =
    securityModeCommand->criticalExtensions.choice.c1.choice.securityModeCommand_r8.securityConfigSMC.securityAlgorithmConfig.integrityProtAlgorithm;
1841

1842 1843 1844 1845
  memset((void *)&ul_dcch_msg,0,sizeof(UL_DCCH_Message_t));
  //memset((void *)&SecurityModeCommand,0,sizeof(SecurityModeCommand_t));

  ul_dcch_msg.message.present           = UL_DCCH_MessageType_PR_c1;
1846

1847
  if (securityMode >= NO_SECURITY_MODE) {
1848
    ul_dcch_msg.message.choice.c1.present = UL_DCCH_MessageType__c1_PR_securityModeComplete;
1849
  } else {
1850
    ul_dcch_msg.message.choice.c1.present = UL_DCCH_MessageType__c1_PR_securityModeFailure;
1851
  }
1852

1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866

#if defined(ENABLE_SECURITY)
  uint8_t *kRRCenc = NULL;
  uint8_t *kUPenc = NULL;
  uint8_t *kRRCint = NULL;
  pdcp_t *pdcp_p = NULL;
  hash_key_t key = HASHTABLE_NOT_A_KEY_VALUE;
  hashtable_rc_t h_rc;

  key = PDCP_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti,
      ctxt_pP->enb_flag, DCCH, SRB_FLAG_YES);
  h_rc = hashtable_get(pdcp_coll_p, key, (void**) &pdcp_p);

  if (h_rc == HASH_TABLE_OK) {
Cedric Roux's avatar
Cedric Roux committed
1867
    LOG_D(RRC, "PDCP_COLL_KEY_VALUE() returns valid key = %ld\n", key);
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 1895 1896 1897 1898 1899 1900 1901 1902 1903

    LOG_D(RRC, "driving kRRCenc, kRRCint and kUPenc from KeNB="
        "%02x%02x%02x%02x"
        "%02x%02x%02x%02x"
        "%02x%02x%02x%02x"
        "%02x%02x%02x%02x"
        "%02x%02x%02x%02x"
        "%02x%02x%02x%02x"
        "%02x%02x%02x%02x"
        "%02x%02x%02x%02x\n",
        UE_rrc_inst[ctxt_pP->module_id].kenb[0],  UE_rrc_inst[ctxt_pP->module_id].kenb[1],  UE_rrc_inst[ctxt_pP->module_id].kenb[2],  UE_rrc_inst[ctxt_pP->module_id].kenb[3],
        UE_rrc_inst[ctxt_pP->module_id].kenb[4],  UE_rrc_inst[ctxt_pP->module_id].kenb[5],  UE_rrc_inst[ctxt_pP->module_id].kenb[6],  UE_rrc_inst[ctxt_pP->module_id].kenb[7],
        UE_rrc_inst[ctxt_pP->module_id].kenb[8],  UE_rrc_inst[ctxt_pP->module_id].kenb[9],  UE_rrc_inst[ctxt_pP->module_id].kenb[10], UE_rrc_inst[ctxt_pP->module_id].kenb[11],
        UE_rrc_inst[ctxt_pP->module_id].kenb[12], UE_rrc_inst[ctxt_pP->module_id].kenb[13], UE_rrc_inst[ctxt_pP->module_id].kenb[14], UE_rrc_inst[ctxt_pP->module_id].kenb[15],
        UE_rrc_inst[ctxt_pP->module_id].kenb[16], UE_rrc_inst[ctxt_pP->module_id].kenb[17], UE_rrc_inst[ctxt_pP->module_id].kenb[18], UE_rrc_inst[ctxt_pP->module_id].kenb[19],
        UE_rrc_inst[ctxt_pP->module_id].kenb[20], UE_rrc_inst[ctxt_pP->module_id].kenb[21], UE_rrc_inst[ctxt_pP->module_id].kenb[22], UE_rrc_inst[ctxt_pP->module_id].kenb[23],
        UE_rrc_inst[ctxt_pP->module_id].kenb[24], UE_rrc_inst[ctxt_pP->module_id].kenb[25], UE_rrc_inst[ctxt_pP->module_id].kenb[26], UE_rrc_inst[ctxt_pP->module_id].kenb[27],
        UE_rrc_inst[ctxt_pP->module_id].kenb[28], UE_rrc_inst[ctxt_pP->module_id].kenb[29], UE_rrc_inst[ctxt_pP->module_id].kenb[30], UE_rrc_inst[ctxt_pP->module_id].kenb[31]);

    derive_key_rrc_enc(UE_rrc_inst[ctxt_pP->module_id].ciphering_algorithm,
        UE_rrc_inst[ctxt_pP->module_id].kenb, &kRRCenc);
    derive_key_rrc_int(UE_rrc_inst[ctxt_pP->module_id].integrity_algorithm,
        UE_rrc_inst[ctxt_pP->module_id].kenb, &kRRCint);
    derive_key_up_enc(UE_rrc_inst[ctxt_pP->module_id].ciphering_algorithm,
        UE_rrc_inst[ctxt_pP->module_id].kenb, &kUPenc);

    if (securityMode != 0xff) {
      pdcp_config_set_security(ctxt_pP, pdcp_p, 0, 0,
          UE_rrc_inst[ctxt_pP->module_id].ciphering_algorithm
              | (UE_rrc_inst[ctxt_pP->module_id].integrity_algorithm << 4),
          kRRCenc, kRRCint, kUPenc);
    } else {
      LOG_W(RRC, "skipped pdcp_config_set_security() as securityMode == 0x%02x",
          securityMode);
    }
  } else {
Cedric Roux's avatar
Cedric Roux committed
1904
    LOG_W(RRC, "Could not get PDCP instance where key=0x%ld\n", key);
1905 1906 1907 1908
  }

#endif //#if defined(ENABLE_SECURITY)

1909
  if (securityModeCommand->criticalExtensions.present == SecurityModeCommand__criticalExtensions_PR_c1) {
1910
    if (securityModeCommand->criticalExtensions.choice.c1.present == SecurityModeCommand__criticalExtensions__c1_PR_securityModeCommand_r8) {
1911

1912
      ul_dcch_msg.message.choice.c1.choice.securityModeComplete.rrc_TransactionIdentifier = securityModeCommand->rrc_TransactionIdentifier;
1913
      ul_dcch_msg.message.choice.c1.choice.securityModeComplete.criticalExtensions.present = SecurityModeCommand__criticalExtensions_PR_c1;
1914
      ul_dcch_msg.message.choice.c1.choice.securityModeComplete.criticalExtensions.choice.securityModeComplete_r8.nonCriticalExtension =NULL;
1915

1916
      LOG_I(RRC,"[UE %d] Frame %d: Receiving from SRB1 (DL-DCCH), encoding securityModeComplete (eNB %d)\n",
1917
            ctxt_pP->module_id,ctxt_pP->frame,eNB_index);
1918

1919 1920 1921 1922 1923 1924
      enc_rval = uper_encode_to_buffer(&asn_DEF_UL_DCCH_Message,
                                       (void*)&ul_dcch_msg,
                                       buffer,
                                       100);
      AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %jd)!\n",
                   enc_rval.failed_type->name, enc_rval.encoded);
1925 1926

#ifdef XER_PRINT
1927 1928
      xer_fprint(stdout, &asn_DEF_UL_DCCH_Message, (void*)&ul_dcch_msg);
#endif
1929

1930 1931
#if defined(ENABLE_ITTI)
# if !defined(DISABLE_XER_SPRINT)
1932 1933 1934
      {
        char        message_string[20000];
        size_t      message_string_size;
1935

1936 1937
        if ((message_string_size = xer_sprint(message_string, sizeof(message_string), &asn_DEF_UL_DCCH_Message, (void *) &ul_dcch_msg)) > 0) {
          MessageDef *msg_p;
1938

1939 1940 1941
          msg_p = itti_alloc_new_message_sized (TASK_RRC_UE, RRC_UL_DCCH, message_string_size + sizeof (IttiMsgText));
          msg_p->ittiMsg.rrc_ul_dcch.size = message_string_size;
          memcpy(&msg_p->ittiMsg.rrc_ul_dcch.text, message_string, message_string_size);
1942

1943
          itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
1944 1945
        }
      }
1946 1947 1948
# endif
#endif

1949
#ifdef USER_MODE
Cedric Roux's avatar
Cedric Roux committed
1950
      LOG_D(RRC, "securityModeComplete Encoded %zd bits (%zd bytes)\n", enc_rval.encoded, (enc_rval.encoded+7)/8);
1951
#endif
1952

1953
      for (i = 0; i < (enc_rval.encoded + 7) / 8; i++) {
1954
        LOG_T(RRC, "%02x.", buffer[i]);
1955
      }
1956 1957

      LOG_T(RRC, "\n");
1958 1959 1960 1961 1962 1963 1964 1965
      rrc_data_req (
		    ctxt_pP,
		    DCCH,
		    rrc_mui++,
		    SDU_CONFIRM_NO,
		    (enc_rval.encoded + 7) / 8,
		    buffer,
		    PDCP_TRANSMISSION_MODE_CONTROL);
1966
    }
1967
  }
1968
}
1969

1970 1971 1972 1973 1974 1975 1976 1977
//-----------------------------------------------------------------------------
void
rrc_ue_process_ueCapabilityEnquiry(
  const protocol_ctxt_t* const ctxt_pP,
  UECapabilityEnquiry_t* UECapabilityEnquiry,
  uint8_t eNB_index
)
//-----------------------------------------------------------------------------
1978
{
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990

  asn_enc_rval_t enc_rval;

  UL_DCCH_Message_t ul_dcch_msg;


  UE_CapabilityRAT_Container_t ue_CapabilityRAT_Container;

  uint8_t buffer[200];
  int i;

  LOG_I(RRC,"[UE %d] Frame %d: Receiving from SRB1 (DL-DCCH), Processing UECapabilityEnquiry (eNB %d)\n",
1991 1992 1993
        ctxt_pP->module_id,
        ctxt_pP->frame,
        eNB_index);
1994 1995 1996 1997 1998 1999 2000


  memset((void *)&ul_dcch_msg,0,sizeof(UL_DCCH_Message_t));
  memset((void *)&ue_CapabilityRAT_Container,0,sizeof(UE_CapabilityRAT_Container_t));

  ul_dcch_msg.message.present           = UL_DCCH_MessageType_PR_c1;
  ul_dcch_msg.message.choice.c1.present = UL_DCCH_MessageType__c1_PR_ueCapabilityInformation;
2001
  ul_dcch_msg.message.choice.c1.choice.ueCapabilityInformation.rrc_TransactionIdentifier = UECapabilityEnquiry->rrc_TransactionIdentifier;
2002 2003 2004

  ue_CapabilityRAT_Container.rat_Type = RAT_Type_eutra;
  OCTET_STRING_fromBuf(&ue_CapabilityRAT_Container.ueCapabilityRAT_Container,
2005 2006
                       (const char*)UE_rrc_inst[ctxt_pP->module_id].UECapability,
                       UE_rrc_inst[ctxt_pP->module_id].UECapability_size);
Lionel Gauthier's avatar
 
Lionel Gauthier committed
2007 2008
  //  ue_CapabilityRAT_Container.ueCapabilityRAT_Container.buf  = UE_rrc_inst[ue_mod_idP].UECapability;
  // ue_CapabilityRAT_Container.ueCapabilityRAT_Container.size = UE_rrc_inst[ue_mod_idP].UECapability_size;
2009

2010 2011

  if (UECapabilityEnquiry->criticalExtensions.present == UECapabilityEnquiry__criticalExtensions_PR_c1) {
2012 2013
    if (UECapabilityEnquiry->criticalExtensions.choice.c1.present == UECapabilityEnquiry__criticalExtensions__c1_PR_ueCapabilityEnquiry_r8) {
      ul_dcch_msg.message.choice.c1.choice.ueCapabilityInformation.criticalExtensions.present           = UECapabilityInformation__criticalExtensions_PR_c1;
2014 2015 2016 2017
      ul_dcch_msg.message.choice.c1.choice.ueCapabilityInformation.criticalExtensions.choice.c1.present =
        UECapabilityInformation__criticalExtensions__c1_PR_ueCapabilityInformation_r8;
      ul_dcch_msg.message.choice.c1.choice.ueCapabilityInformation.criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list.count
        =0;
2018

2019
      for (i=0; i<UECapabilityEnquiry->criticalExtensions.choice.c1.choice.ueCapabilityEnquiry_r8.ue_CapabilityRequest.list.count; i++) {
2020

2021 2022 2023 2024 2025
        if (*UECapabilityEnquiry->criticalExtensions.choice.c1.choice.ueCapabilityEnquiry_r8.ue_CapabilityRequest.list.array[i]
            == RAT_Type_eutra) {
          ASN_SEQUENCE_ADD(
            &ul_dcch_msg.message.choice.c1.choice.ueCapabilityInformation.criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list,
            &ue_CapabilityRAT_Container);
2026

2027 2028 2029
          enc_rval = uper_encode_to_buffer(&asn_DEF_UL_DCCH_Message, (void*) &ul_dcch_msg, buffer, 100);
          AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %jd)!\n",
                       enc_rval.failed_type->name, enc_rval.encoded);
2030 2031

#ifdef XER_PRINT
2032
          xer_fprint(stdout, &asn_DEF_UL_DCCH_Message, (void*)&ul_dcch_msg);
2033
#endif
2034

2035 2036
#if defined(ENABLE_ITTI)
# if !defined(DISABLE_XER_SPRINT)
2037 2038 2039
          {
            char        message_string[20000];
            size_t      message_string_size;
2040

2041 2042
            if ((message_string_size = xer_sprint(message_string, sizeof(message_string), &asn_DEF_UL_DCCH_Message, (void *) &ul_dcch_msg)) > 0) {
              MessageDef *msg_p;
2043

2044 2045 2046
              msg_p = itti_alloc_new_message_sized (TASK_RRC_UE, RRC_UL_DCCH, message_string_size + sizeof (IttiMsgText));
              msg_p->ittiMsg.rrc_ul_dcch.size = message_string_size;
              memcpy(&msg_p->ittiMsg.rrc_ul_dcch.text, message_string, message_string_size);
2047

2048
              itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
2049 2050
            }
          }
2051 2052 2053
# endif
#endif

2054
#ifdef USER_MODE
Cedric Roux's avatar
Cedric Roux committed
2055
          LOG_D(RRC,"UECapabilityInformation Encoded %zd bits (%zd bytes)\n",enc_rval.encoded,(enc_rval.encoded+7)/8);
2056
#endif
2057

2058
          for (i = 0; i < (enc_rval.encoded + 7) / 8; i++) {
2059
            LOG_T(RRC, "%02x.", buffer[i]);
2060
          }
2061 2062

          LOG_T(RRC, "\n");
2063 2064 2065 2066 2067 2068 2069 2070
          rrc_data_req (
			ctxt_pP,
			DCCH,
			rrc_mui++,
			SDU_CONFIRM_NO,
			(enc_rval.encoded + 7) / 8,
			buffer,
			PDCP_TRANSMISSION_MODE_CONTROL);
2071
        }
2072
      }
2073
    }
2074 2075 2076
  }
}

2077

2078 2079 2080 2081
//-----------------------------------------------------------------------------
void
rrc_ue_process_rrcConnectionReconfiguration(
  const protocol_ctxt_t* const       ctxt_pP,
2082
  RRCConnectionReconfiguration_t *rrcConnectionReconfiguration,
2083 2084 2085
  uint8_t eNB_index
)
//-----------------------------------------------------------------------------
2086
{
2087

2088
  LOG_I(RRC,"[UE %d] Frame %d: Receiving from SRB1 (DL-DCCH), Processing RRCConnectionReconfiguration (eNB %d)\n",
2089
        ctxt_pP->module_id,ctxt_pP->frame,eNB_index);
2090

2091
  if (rrcConnectionReconfiguration->criticalExtensions.present == RRCConnectionReconfiguration__criticalExtensions_PR_c1) {
2092 2093
    if (rrcConnectionReconfiguration->criticalExtensions.choice.c1.present ==
        RRCConnectionReconfiguration__criticalExtensions__c1_PR_rrcConnectionReconfiguration_r8) {
2094 2095
      RRCConnectionReconfiguration_r8_IEs_t* rrcConnectionReconfiguration_r8 =
        &rrcConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8;
Lionel Gauthier's avatar
Lionel Gauthier committed
2096

2097 2098
      if (rrcConnectionReconfiguration_r8->mobilityControlInfo) {
        LOG_I(RRC,"Mobility Control Information is present\n");
2099 2100 2101 2102
        rrc_ue_process_mobilityControlInfo(
          ctxt_pP,
          eNB_index,
          rrcConnectionReconfiguration_r8->mobilityControlInfo);
2103 2104 2105 2106
      }

      if (rrcConnectionReconfiguration_r8->measConfig != NULL) {
        LOG_I(RRC,"Measurement Configuration is present\n");
2107 2108
        rrc_ue_process_measConfig(ctxt_pP,
                                  eNB_index,
2109 2110 2111 2112 2113
                                  rrcConnectionReconfiguration_r8->measConfig);
      }

      if (rrcConnectionReconfiguration_r8->radioResourceConfigDedicated) {
        LOG_I(RRC,"Radio Resource Configuration is present\n");
2114
        rrc_ue_process_radioResourceConfigDedicated(ctxt_pP,eNB_index, rrcConnectionReconfiguration_r8->radioResourceConfigDedicated);
2115
      }
2116

2117 2118
      //TTN for D2D
      //if RRCConnectionReconfiguration message includes the sl-CommConfig
2119 2120
      //***Panos: Comment lines 2117-2137 temporarily
      /*if (rrcConnectionReconfiguration_r8->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->sl_CommConfig_r12->commTxResources_r12->present != SL_CommConfig_r12__commTxResources_r12_PR_NOTHING){
2121
         LOG_I(RRC,"sl-CommConfig is present\n");
2122
         //process sl-CommConfig
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
2123
         rrc_ue_process_sidelink_radioResourceConfig(ctxt_pP->module_id,eNB_index,
2124 2125 2126 2127 2128
               (SystemInformationBlockType18_r12_t *)NULL,
               (SystemInformationBlockType19_r12_t *)NULL,
               rrcConnectionReconfiguration_r8->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->sl_CommConfig_r12,
               (SL_DiscConfig_r12_t *)NULL
               );
2129 2130 2131
      }
      //if RRCConnectionReconfiguration message includes the sl-DiscConfig
      if (rrcConnectionReconfiguration_r8->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->sl_DiscConfig_r12->discTxResources_r12->present != SL_DiscConfig_r12__discTxResources_r12_PR_NOTHING ){
2132 2133
         LOG_I(RRC,"sl-DiscConfig is present\n");
         //process sl-DiscConfig
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
2134
         rrc_ue_process_sidelink_radioResourceConfig(ctxt_pP->module_id,eNB_index,
2135 2136 2137 2138 2139
               (SystemInformationBlockType18_r12_t *)NULL,
               (SystemInformationBlockType19_r12_t *)NULL,
               (SL_CommConfig_r12_t* )NULL,
               rrcConnectionReconfiguration_r8->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->sl_DiscConfig_r12
               );
2140
      }*/
2141 2142


2143 2144
#if defined(ENABLE_ITTI)

2145 2146 2147 2148 2149 2150
      /* Check if there is dedicated NAS information to forward to NAS */
      if (rrcConnectionReconfiguration_r8->dedicatedInfoNASList != NULL) {
        int list_count;
        uint32_t pdu_length;
        uint8_t *pdu_buffer;
        MessageDef *msg_p;
2151

2152 2153 2154
        for (list_count = 0; list_count < rrcConnectionReconfiguration_r8->dedicatedInfoNASList->list.count; list_count++) {
          pdu_length = rrcConnectionReconfiguration_r8->dedicatedInfoNASList->list.array[list_count]->size;
          pdu_buffer = rrcConnectionReconfiguration_r8->dedicatedInfoNASList->list.array[list_count]->buf;
2155

2156 2157 2158 2159
          msg_p = itti_alloc_new_message(TASK_RRC_UE, NAS_CONN_ESTABLI_CNF);
          NAS_CONN_ESTABLI_CNF(msg_p).errCode = AS_SUCCESS;
          NAS_CONN_ESTABLI_CNF(msg_p).nasMsg.length = pdu_length;
          NAS_CONN_ESTABLI_CNF(msg_p).nasMsg.data = pdu_buffer;
2160

2161
          itti_send_msg_to_task(TASK_NAS_UE, ctxt_pP->instance, msg_p);
2162
        }
2163

2164 2165
        free (rrcConnectionReconfiguration_r8->dedicatedInfoNASList);
      }
2166

2167
#if ENABLE_RAL
2168 2169 2170 2171 2172 2173 2174 2175
      {
        MessageDef                                 *message_ral_p = NULL;
        rrc_ral_connection_reestablishment_ind_t    connection_reestablishment_ind;
        int                                         i;

        message_ral_p = itti_alloc_new_message (TASK_RRC_UE, RRC_RAL_CONNECTION_REESTABLISHMENT_IND);
        memset(&connection_reestablishment_ind, 0, sizeof(rrc_ral_connection_reestablishment_ind_t));
        // TO DO ral_si_ind.plmn_id        = 0;
2176
        connection_reestablishment_ind.ue_id            = ctxt_pP->rnti;
2177 2178 2179 2180 2181

        if (rrcConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList != NULL) {
          connection_reestablishment_ind.num_drb      =
            rrcConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList->list.count;

2182 2183 2184
          for (i=0; (
                 i<rrcConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList->list.count)
               && (i < maxDRB); i++) {
2185 2186 2187
            // why minus 1 in RRC code for drb_identity ?
            connection_reestablishment_ind.drb_id[i]   =
              rrcConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList->list.array[i]->drb_Identity;
2188
          }
2189 2190 2191 2192 2193 2194
        } else {
          connection_reestablishment_ind.num_drb      = 0;
        }

        if (rrcConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->srb_ToAddModList != NULL) {
          connection_reestablishment_ind.num_srb      =
2195 2196
            rrcConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->srb_ToAddModList->list.count +
            UE_rrc_inst[ctxt_pP->module_id].num_srb;
2197 2198

        } else {
2199
          connection_reestablishment_ind.num_srb      += UE_rrc_inst[ctxt_pP->module_id].num_srb;
2200 2201
        }

2202
        if (connection_reestablishment_ind.num_srb > 2) { // fixme: only 2 srbs can exist, adjust the value
2203
          connection_reestablishment_ind.num_srb =2;
2204
        }
2205 2206 2207 2208

        memcpy (&message_ral_p->ittiMsg, (void *) &connection_reestablishment_ind, sizeof(rrc_ral_connection_reestablishment_ind_t));
        //#warning "ue_mod_idP ? for instance ? => YES"
        LOG_I(RRC, "Sending RRC_RAL_CONNECTION_REESTABLISHMENT_IND to mRAL\n");
2209
        itti_send_msg_to_task (TASK_RAL_UE, ctxt_pP->instance, message_ral_p);
2210
      }
Lionel Gauthier's avatar
Lionel Gauthier committed
2211
#endif
2212
#endif
2213
    } // c1 present
2214
  } // critical extensions present
2215 2216
}

2217
/* 36.331, 5.3.5.4      Reception of an RRCConnectionReconfiguration including the mobilityControlInfo by the UE (handover) */
2218 2219 2220 2221 2222 2223 2224 2225
//-----------------------------------------------------------------------------
void
rrc_ue_process_mobilityControlInfo(
  const protocol_ctxt_t* const       ctxt_pP,
  const uint8_t                      eNB_index,
  struct MobilityControlInfo* const mobilityControlInfo
)
//-----------------------------------------------------------------------------
2226
{
2227
  /*
2228 2229
  DRB_ToReleaseList_t*  drb2release_list;
  DRB_Identity_t *lcid;
2230
   */
2231
  LOG_N(RRC,"Note: This function needs some updates\n");
2232

2233 2234 2235
  if(UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].T310_active == 1) {
    UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].T310_active = 0;
  }
2236

2237 2238
  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].T304_active = 1;
  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].T304_cnt = T304[mobilityControlInfo->t304];
2239

2240
  /*
2241 2242 2243
  drb2release_list = CALLOC (1, sizeof (*drb2release_list));
  lcid= CALLOC (1, sizeof (DRB_Identity_t)); // long
  for (*lcid=0;*lcid<NB_RB_MAX;*lcid++)
2244
  {
2245
    ASN_SEQUENCE_ADD (&(drb2release_list)->list,lcid);
2246
  }
2247
   */
2248
  //Removing SRB1 and SRB2 and DRB0
2249 2250 2251 2252 2253 2254 2255
  LOG_N(RRC,"[UE %d] : Update needed for rrc_pdcp_config_req (deprecated) and rrc_rlc_config_req commands(deprecated)\n", ctxt_pP->module_id);
  rrc_pdcp_config_req (ctxt_pP, SRB_FLAG_YES, CONFIG_ACTION_REMOVE, DCCH,UNDEF_SECURITY_MODE);
  rrc_rlc_config_req(ctxt_pP, SRB_FLAG_YES, MBMS_FLAG_NO, CONFIG_ACTION_REMOVE,ctxt_pP->module_id+DCCH,Rlc_info_am_config);
  rrc_pdcp_config_req (ctxt_pP, SRB_FLAG_YES, CONFIG_ACTION_REMOVE, DCCH1,UNDEF_SECURITY_MODE);
  rrc_rlc_config_req(ctxt_pP, SRB_FLAG_YES,CONFIG_ACTION_REMOVE, MBMS_FLAG_NO,ctxt_pP->module_id+DCCH1,Rlc_info_am_config);
  rrc_pdcp_config_req (ctxt_pP, SRB_FLAG_NO, CONFIG_ACTION_REMOVE, DTCH,UNDEF_SECURITY_MODE);
  rrc_rlc_config_req(ctxt_pP, SRB_FLAG_NO,CONFIG_ACTION_REMOVE, MBMS_FLAG_NO,ctxt_pP->module_id+DTCH,Rlc_info_um);
2256
  /*
Lionel Gauthier's avatar
 
Lionel Gauthier committed
2257
  rrc_pdcp_config_asn1_req(NB_eNB_INST+ue_mod_idP,frameP, 0,eNB_index,
2258 2259 2260 2261 2262 2263 2264
         NULL, // SRB_ToAddModList
         NULL, // DRB_ToAddModList
         drb2release_list,
         0, // security mode
         NULL, // key rrc encryption
         NULL, // key rrc integrity
         NULL // key encryption
Cedric Roux's avatar
Cedric Roux committed
2265
#if defined(Rel10) || defined(Rel14)
2266
         ,NULL
Cedric Roux's avatar
Cedric Roux committed
2267
#endif
2268
         ,NULL);
2269

Lionel Gauthier's avatar
 
Lionel Gauthier committed
2270
  rrc_rlc_config_asn1_req(NB_eNB_INST+ue_mod_idP, frameP,0,eNB_index,
2271 2272 2273
        NULL,// SRB_ToAddModList
        NULL,// DRB_ToAddModList
        drb2release_list // DRB_ToReleaseList
Cedric Roux's avatar
Cedric Roux committed
2274
#if defined(Rel10) || defined(Rel14)
2275
        ,NULL
Cedric Roux's avatar
Cedric Roux committed
2276
#endif
2277
        ,NULL);
2278
   */
2279

2280 2281 2282 2283

  //A little cleanup at RRC...
  //Copying current queue config to free RRC index
  /*
Lionel Gauthier's avatar
 
Lionel Gauthier committed
2284 2285 2286
    memcpy((void *)UE_rrc_inst[ue_mod_idP].SRB1_config[~(7<<eNB_index)],(void *)UE_rrc_inst[ue_mod_idP].SRB1_config[7<<eNB_index],sizeof(SRB_ToAddMod_t));
    memcpy((void *)UE_rrc_inst[ue_mod_idP].SRB2_config[~(7<<eNB_index)],(void *)UE_rrc_inst[ue_mod_idP].SRB2_config[7<<eNB_index],sizeof(SRB_ToAddMod_t));
    memcpy((void *)UE_rrc_inst[ue_mod_idP].DRB_config[~(7<<eNB_index)][0],(void *)UE_rrc_inst[ue_mod_idP].DRB_config[7<<eNB_index][0],sizeof(DRB_ToAddMod_t));
2287
   */
2288 2289
  /*
  LOG_N(RRC,"Not sure if Freeing the current queue config works properly: Fix me\n");
Lionel Gauthier's avatar
 
Lionel Gauthier committed
2290 2291 2292
  free((void *)&UE_rrc_inst[ue_mod_idP].SRB1_config[eNB_index]);
  free((void *)&UE_rrc_inst[ue_mod_idP].SRB2_config[eNB_index]);
  free((void *)&UE_rrc_inst[ue_mod_idP].DRB_config[eNB_index][0]);
2293

Lionel Gauthier's avatar
 
Lionel Gauthier committed
2294 2295 2296
  UE_rrc_inst[ue_mod_idP].SRB1_config[eNB_index] = NULL;
  UE_rrc_inst[ue_mod_idP].SRB2_config[eNB_index] = NULL;
  UE_rrc_inst[ue_mod_idP].DRB_config[eNB_index][0] = NULL;
2297
   */
2298
  //Synchronisation to DL of target cell
2299
  LOG_I(RRC,
Lionel Gauthier's avatar
Lionel Gauthier committed
2300
        "HO: Reset PDCP and RLC for configured RBs.. \n[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ  (SRB2 eNB %d) --->][MAC_UE][MOD %02d][]\n",
2301
        ctxt_pP->frame, ctxt_pP->module_id, eNB_index, ctxt_pP->module_id);
2302 2303

  // Reset MAC and configure PHY
2304 2305 2306 2307 2308
  rrc_mac_config_req_ue(ctxt_pP->module_id,
			0,
			eNB_index,
			(RadioResourceConfigCommonSIB_t *)NULL,
			(struct PhysicalConfigDedicated *)NULL,
Cedric Roux's avatar
Cedric Roux committed
2309
#if defined(Rel10) || defined(Rel14)
2310 2311
			(SCellToAddMod_r10_t *)NULL,
			//(struct PhysicalConfigDedicatedSCell_r10 *)NULL,
2312
#endif
2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325
			(MeasObjectToAddMod_t **)NULL,
			(MAC_MainConfig_t *)NULL,
			0,
			(struct LogicalChannelConfig *)NULL,
			(MeasGapConfig_t *)NULL,
			(TDD_Config_t *)NULL,
			mobilityControlInfo,
			(uint8_t *)NULL,
			(uint16_t *)NULL,
			NULL,
			NULL,
			NULL,
			NULL
Cedric Roux's avatar
Cedric Roux committed
2326
#if defined(Rel10) || defined(Rel14)
2327 2328 2329
			,0,
			(MBSFN_AreaInfoList_r9_t *)NULL,
			(PMCH_InfoList_r9_t *)NULL
2330 2331
#endif
#ifdef CBA
2332 2333
			,0,
			0
2334 2335 2336
#endif
#if defined(Rel14)
           ,
2337
           0,
2338
           NULL,
2339
           NULL
2340
#endif
2341
			);
2342

2343
  // Re-establish PDCP for all RBs that are established
Lionel Gauthier's avatar
 
Lionel Gauthier committed
2344 2345 2346
  // rrc_pdcp_config_req (ue_mod_idP+NB_eNB_INST, frameP, 0, CONFIG_ACTION_ADD, ue_mod_idP+DCCH);
  // rrc_pdcp_config_req (ue_mod_idP+NB_eNB_INST, frameP, 0, CONFIG_ACTION_ADD, ue_mod_idP+DCCH1);
  // rrc_pdcp_config_req (ue_mod_idP+NB_eNB_INST, frameP, 0, CONFIG_ACTION_ADD, ue_mod_idP+DTCH);
2347 2348


2349
  // Re-establish RLC for all RBs that are established
Lionel Gauthier's avatar
 
Lionel Gauthier committed
2350 2351 2352
  // rrc_rlc_config_req(ue_mod_idP+NB_eNB_INST,frameP,0,CONFIG_ACTION_ADD,ue_mod_idP+DCCH,SIGNALLING_RADIO_BEARER,Rlc_info_am_config);
  // rrc_rlc_config_req(ue_mod_idP+NB_eNB_INST,frameP,0,CONFIG_ACTION_ADD,ue_mod_idP+DCCH1,SIGNALLING_RADIO_BEARER,Rlc_info_am_config);
  // rrc_rlc_config_req(ue_mod_idP+NB_eNB_INST,frameP,0,CONFIG_ACTION_ADD,ue_mod_idP+DTCH,RADIO_ACCESS_BEARER,Rlc_info_um);
2353
  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].State = RRC_SI_RECEIVED;
2354
}
2355 2356 2357 2358 2359 2360 2361 2362

//-----------------------------------------------------------------------------
void
rrc_detach_from_eNB(
  module_id_t ue_mod_idP,
  uint8_t eNB_index
)
//-----------------------------------------------------------------------------
2363
{
Lionel Gauthier's avatar
 
Lionel Gauthier committed
2364
  //UE_rrc_inst[ue_mod_idP].DRB_config[eNB_index]
2365 2366
}

2367 2368 2369 2370 2371 2372 2373 2374 2375
//-----------------------------------------------------------------------------
void
rrc_ue_decode_dcch(
  const protocol_ctxt_t* const ctxt_pP,
  const rb_id_t                Srb_id,
  const uint8_t*         const Buffer,
  const uint8_t                eNB_indexP
)
//-----------------------------------------------------------------------------
2376
{
2377 2378 2379 2380

  //DL_DCCH_Message_t dldcchmsg;
  DL_DCCH_Message_t *dl_dcch_msg=NULL;//&dldcchmsg;
  //  asn_dec_rval_t dec_rval;
2381
  // int i;
2382
  uint8_t target_eNB_index=0xFF;
winckel's avatar
winckel committed
2383 2384 2385 2386
#if defined(ENABLE_ITTI)
  MessageDef *msg_p;
#endif

2387
  if (Srb_id != 1) {
2388
    LOG_E(RRC,"[UE %d] Frame %d: Received message on DL-DCCH (SRB%d), should not have ...\n",
2389
          ctxt_pP->module_id, ctxt_pP->frame, Srb_id);
2390
    return;
2391 2392 2393 2394 2395
  }

  //memset(dl_dcch_msg,0,sizeof(DL_DCCH_Message_t));

  // decode messages
Lionel Gauthier's avatar
 
Lionel Gauthier committed
2396
  //  LOG_D(RRC,"[UE %d] Decoding DL-DCCH message\n",ue_mod_idP);
2397 2398 2399 2400
  /*
  for (i=0;i<30;i++)
    LOG_T(RRC,"%x.",Buffer[i]);
  LOG_T(RRC, "\n");
2401
   */
2402
  uper_decode(NULL,
2403 2404 2405 2406
              &asn_DEF_DL_DCCH_Message,
              (void**)&dl_dcch_msg,
              (uint8_t*)Buffer,
              RRC_BUF_SIZE,0,0);
2407 2408 2409 2410 2411

#ifdef XER_PRINT
  xer_fprint(stdout,&asn_DEF_DL_DCCH_Message,(void*)dl_dcch_msg);
#endif

2412
#if defined(ENABLE_ITTI)
2413
# if defined(DISABLE_ITTI_XER_PRINT)
2414
  {
winckel's avatar
winckel committed
2415 2416
    msg_p = itti_alloc_new_message (TASK_RRC_UE, RRC_DL_DCCH_MESSAGE);
    memcpy (&msg_p->ittiMsg, (void *) dl_dcch_msg, sizeof(RrcDlDcchMessage));
2417

2418
    itti_send_msg_to_task (TASK_UNKNOWN, ctxt_pP->instance, msg_p);
2419
  }
2420 2421
# else
  {
2422
    char        message_string[30000];
2423
    size_t      message_string_size;
2424

2425 2426 2427 2428
    if ((message_string_size = xer_sprint(message_string, sizeof(message_string), &asn_DEF_DL_DCCH_Message, (void *)dl_dcch_msg)) > 0) {
      msg_p = itti_alloc_new_message_sized (TASK_RRC_UE, RRC_DL_DCCH, message_string_size + sizeof (IttiMsgText));
      msg_p->ittiMsg.rrc_dl_dcch.size = message_string_size;
      memcpy(&msg_p->ittiMsg.rrc_dl_dcch.text, message_string, message_string_size);
2429

2430
      itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
2431
    }
2432 2433
  }
# endif
2434 2435
#endif

2436 2437
  if (dl_dcch_msg->message.present == DL_DCCH_MessageType_PR_c1) {

2438
    if (UE_rrc_inst[ctxt_pP->module_id].Info[eNB_indexP].State >= RRC_CONNECTED) {
2439

2440
      switch (dl_dcch_msg->message.choice.c1.present) {
2441

2442
      case DL_DCCH_MessageType__c1_PR_NOTHING:
2443 2444
        LOG_I(RRC, "[UE %d] Frame %d : Received PR_NOTHING on DL-DCCH-Message\n",
              ctxt_pP->module_id, ctxt_pP->frame);
2445
        return;
winckel's avatar
RRC:  
winckel committed
2446

2447 2448
      case DL_DCCH_MessageType__c1_PR_csfbParametersResponseCDMA2000:
        break;
2449

2450
      case DL_DCCH_MessageType__c1_PR_dlInformationTransfer: {
winckel's avatar
RRC:  
winckel committed
2451
#if defined(ENABLE_ITTI)
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469
        DLInformationTransfer_t *dlInformationTransfer = &dl_dcch_msg->message.choice.c1.choice.dlInformationTransfer;

        if ((dlInformationTransfer->criticalExtensions.present == DLInformationTransfer__criticalExtensions_PR_c1)
            && (dlInformationTransfer->criticalExtensions.choice.c1.present
                == DLInformationTransfer__criticalExtensions__c1_PR_dlInformationTransfer_r8)
            && (dlInformationTransfer->criticalExtensions.choice.c1.choice.dlInformationTransfer_r8.dedicatedInfoType.present
                == DLInformationTransfer_r8_IEs__dedicatedInfoType_PR_dedicatedInfoNAS)) {
          /* This message hold a dedicated info NAS payload, forward it to NAS */
          struct DLInformationTransfer_r8_IEs__dedicatedInfoType *dedicatedInfoType =
                &dlInformationTransfer->criticalExtensions.choice.c1.choice.dlInformationTransfer_r8.dedicatedInfoType;
          uint32_t pdu_length;
          uint8_t *pdu_buffer;
          MessageDef *msg_p;

          pdu_length = dedicatedInfoType->choice.dedicatedInfoNAS.size;
          pdu_buffer = dedicatedInfoType->choice.dedicatedInfoNAS.buf;

          msg_p = itti_alloc_new_message(TASK_RRC_UE, NAS_DOWNLINK_DATA_IND);
2470
          NAS_DOWNLINK_DATA_IND(msg_p).UEid = ctxt_pP->module_id; // TODO set the UEid to something else ?
2471 2472 2473
          NAS_DOWNLINK_DATA_IND(msg_p).nasMsg.length = pdu_length;
          NAS_DOWNLINK_DATA_IND(msg_p).nasMsg.data = pdu_buffer;

2474
          itti_send_msg_to_task(TASK_NAS_UE, ctxt_pP->instance, msg_p);
2475 2476
        }

winckel's avatar
RRC:  
winckel committed
2477
#endif
2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492
        break;
      }

      case DL_DCCH_MessageType__c1_PR_handoverFromEUTRAPreparationRequest:
        break;

      case DL_DCCH_MessageType__c1_PR_mobilityFromEUTRACommand:
        break;

      case DL_DCCH_MessageType__c1_PR_rrcConnectionReconfiguration:

        // first check if mobilityControlInfo  is present
        if (dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.mobilityControlInfo
            != NULL) {
          /* 36.331, 5.3.5.4 Reception of an RRCConnectionReconfiguration including the mobilityControlInfo by the UE (handover)*/
2493
          if (UE_rrc_inst[ctxt_pP->module_id].HandoverInfoUe.targetCellId
2494 2495
              != dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.mobilityControlInfo->targetPhysCellId) {
            LOG_W(RRC,
Cedric Roux's avatar
Cedric Roux committed
2496
                  "[UE %d] Frame %d: Handover target (%ld) is different from RSRP measured target (%ld)..\n",
2497 2498
                  ctxt_pP->module_id,
                  ctxt_pP->frame,
2499
                  dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.mobilityControlInfo->targetPhysCellId,
2500
                  UE_rrc_inst[ctxt_pP->module_id].HandoverInfoUe.targetCellId);
2501
            return;
2502
          } else if ((target_eNB_index = get_adjacent_cell_mod_id(UE_rrc_inst[ctxt_pP->module_id].HandoverInfoUe.targetCellId))
2503 2504
                     == 0xFF) {
            LOG_W(RRC,
2505 2506 2507
                  "[UE %d] Frame %d: ue_mod_idP of the target eNB not found, check the network topology\n",
                  ctxt_pP->module_id,
                  ctxt_pP->frame);
2508 2509 2510
            return;
          } else {
            LOG_I(RRC,
2511 2512 2513 2514
                  "[UE% d] Frame %d: Received rrcConnectionReconfiguration with mobilityControlInfo \n",
                  ctxt_pP->module_id,
                  ctxt_pP->frame);
            UE_rrc_inst[ctxt_pP->module_id].HandoverInfoUe.measFlag = 1; // Ready to send more MeasReports if required
2515
          }
2516
        }
2517

2518 2519 2520 2521
        rrc_ue_process_rrcConnectionReconfiguration(
          ctxt_pP,
          &dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration,
          eNB_indexP);
2522 2523

        if (target_eNB_index != 0xFF) {
2524 2525 2526
          rrc_ue_generate_RRCConnectionReconfigurationComplete(
            ctxt_pP,
            target_eNB_index,
2527
            dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.rrc_TransactionIdentifier);
2528 2529 2530 2531
          UE_rrc_inst[ctxt_pP->module_id].Info[eNB_indexP].State = RRC_HO_EXECUTION;
          UE_rrc_inst[ctxt_pP->module_id].Info[target_eNB_index].State = RRC_RECONFIGURED;
          LOG_I(RRC, "[UE %d] State = RRC_RECONFIGURED during HO (eNB %d)\n",
                ctxt_pP->module_id, target_eNB_index);
Lionel Gauthier's avatar
Lionel Gauthier committed
2532
#if defined(ENABLE_ITTI)
2533
#if ENABLE_RAL
2534 2535 2536 2537 2538 2539 2540
          {
            MessageDef                                 *message_ral_p = NULL;
            rrc_ral_connection_reconfiguration_ho_ind_t connection_reconfiguration_ho_ind;
            int                                         i;

            message_ral_p = itti_alloc_new_message (TASK_RRC_UE, RRC_RAL_CONNECTION_RECONFIGURATION_HO_IND);
            memset(&connection_reconfiguration_ho_ind, 0, sizeof(rrc_ral_connection_reconfiguration_ho_ind_t));
2541
            connection_reconfiguration_ho_ind.ue_id = ctxt_pP->module_id;
2542

2543 2544
            if (dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList
                != NULL) {
2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558
              connection_reconfiguration_ho_ind.num_drb      =
                dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList->list.count;

              for (i=0; (
                     i<dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList->list.count)
                   && (i < maxDRB); i++) {
                // why minus 1 in RRC code for drb_identity ?
                connection_reconfiguration_ho_ind.drb_id[i]   =
                  dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList->list.array[i]->drb_Identity;
              }
            } else {
              connection_reconfiguration_ho_ind.num_drb      = 0;
            }

2559 2560
            if (dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->srb_ToAddModList
                != NULL) {
2561
              connection_reconfiguration_ho_ind.num_srb      =
2562 2563 2564
                dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->srb_ToAddModList->list.count
                +
                UE_rrc_inst[ctxt_pP->module_id].num_srb;
2565
            } else {
2566
              connection_reconfiguration_ho_ind.num_srb      += UE_rrc_inst[ctxt_pP->module_id].num_srb;
2567 2568
            }

2569
            if (connection_reconfiguration_ho_ind.num_srb > 2 ) {
2570
              connection_reconfiguration_ho_ind.num_srb =2;
2571
            }
2572 2573 2574 2575

            memcpy (&message_ral_p->ittiMsg, (void *) &connection_reconfiguration_ho_ind, sizeof(rrc_ral_connection_reconfiguration_ho_ind_t));
            //#warning "ue_mod_idP ? for instance ? => YES"
            LOG_I(RRC, "Sending RRC_RAL_CONNECTION_RECONFIGURATION_HO_IND to mRAL\n");
2576
            itti_send_msg_to_task (TASK_RAL_UE, ctxt_pP->instance, message_ral_p);
2577
          }
Lionel Gauthier's avatar
Lionel Gauthier committed
2578 2579
#endif
#endif
2580
        } else {
2581 2582 2583
          rrc_ue_generate_RRCConnectionReconfigurationComplete(
            ctxt_pP,
            eNB_indexP,
2584
            dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.rrc_TransactionIdentifier);
2585 2586 2587 2588
          UE_rrc_inst[ctxt_pP->module_id].Info[eNB_indexP].State = RRC_RECONFIGURED;
          LOG_I(RRC, "[UE %d] State = RRC_RECONFIGURED (eNB %d)\n",
                ctxt_pP->module_id,
                eNB_indexP);
Lionel Gauthier's avatar
Lionel Gauthier committed
2589
#if defined(ENABLE_ITTI)
2590
#if ENABLE_RAL
2591 2592 2593 2594 2595 2596 2597
          {
            MessageDef                                 *message_ral_p = NULL;
            rrc_ral_connection_reconfiguration_ind_t    connection_reconfiguration_ind;
            int                                         i;

            message_ral_p = itti_alloc_new_message (TASK_RRC_UE, RRC_RAL_CONNECTION_RECONFIGURATION_IND);
            memset(&connection_reconfiguration_ind, 0, sizeof(rrc_ral_connection_reconfiguration_ind_t));
2598
            connection_reconfiguration_ind.ue_id = ctxt_pP->module_id;
2599

2600 2601
            if (dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList
                != NULL) {
2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615
              connection_reconfiguration_ind.num_drb      =
                dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList->list.count;

              for (i=0; (
                     i<dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList->list.count)
                   && (i < maxDRB); i++) {
                // why minus 1 in RRC code for drb_identity ?
                connection_reconfiguration_ind.drb_id[i]   =
                  dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->drb_ToAddModList->list.array[i]->drb_Identity;
              }
            } else {
              connection_reconfiguration_ind.num_drb      = 0;
            }

2616 2617
            if (dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->srb_ToAddModList
                != NULL) {
2618
              connection_reconfiguration_ind.num_srb      =
2619 2620 2621
                dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.radioResourceConfigDedicated->srb_ToAddModList->list.count
                +
                UE_rrc_inst[ctxt_pP->module_id].num_srb;
2622
            } else {
2623
              connection_reconfiguration_ind.num_srb      +=UE_rrc_inst[ctxt_pP->module_id].num_srb;
2624 2625
            }

2626
            if (connection_reconfiguration_ind.num_srb > 2 ) {
2627
              connection_reconfiguration_ind.num_srb =2;
2628
            }
2629 2630 2631 2632

            memcpy (&message_ral_p->ittiMsg, (void *) &connection_reconfiguration_ind, sizeof(rrc_ral_connection_reconfiguration_ind_t));
            //#warning "ue_mod_idP ? for instance ? => YES"
            LOG_I(RRC, "Sending RRC_RAL_CONNECTION_RECONFIGURATION_IND to mRAL\n");
2633
            itti_send_msg_to_task (TASK_RAL_UE, ctxt_pP->instance, message_ral_p);
2634
          }
Lionel Gauthier's avatar
Lionel Gauthier committed
2635 2636 2637
#endif
#endif

2638 2639 2640
        }

        break;
2641

2642
      case DL_DCCH_MessageType__c1_PR_rrcConnectionRelease:
2643
#if defined(ENABLE_ITTI)
2644 2645 2646 2647 2648 2649 2650 2651 2652
        msg_p = itti_alloc_new_message(TASK_RRC_UE, NAS_CONN_RELEASE_IND);

        if ((dl_dcch_msg->message.choice.c1.choice.rrcConnectionRelease.criticalExtensions.present
             == RRCConnectionRelease__criticalExtensions_PR_c1)
            && (dl_dcch_msg->message.choice.c1.choice.rrcConnectionRelease.criticalExtensions.choice.c1.present
                == RRCConnectionRelease__criticalExtensions__c1_PR_rrcConnectionRelease_r8)) {
          NAS_CONN_RELEASE_IND(msg_p).cause =
            dl_dcch_msg->message.choice.c1.choice.rrcConnectionRelease.criticalExtensions.choice.c1.choice.rrcConnectionRelease_r8.releaseCause;
        }
winckel's avatar
winckel committed
2653

2654
        itti_send_msg_to_task(TASK_NAS_UE, ctxt_pP->instance, msg_p);
2655
#if ENABLE_RAL
2656
        msg_p = itti_alloc_new_message(TASK_RRC_UE, RRC_RAL_CONNECTION_RELEASE_IND);
2657 2658
        RRC_RAL_CONNECTION_RELEASE_IND(msg_p).ue_id = ctxt_pP->module_id;
        itti_send_msg_to_task(TASK_RAL_UE, ctxt_pP->instance, msg_p);
Lionel Gauthier's avatar
Lionel Gauthier committed
2659
#endif
2660
#endif
2661
        break;
2662

2663
      case DL_DCCH_MessageType__c1_PR_securityModeCommand:
2664 2665 2666 2667 2668 2669
        LOG_I(RRC, "[UE %d] Received securityModeCommand (eNB %d)\n",
              ctxt_pP->module_id, eNB_indexP);
        rrc_ue_process_securityModeCommand(
          ctxt_pP,
          &dl_dcch_msg->message.choice.c1.choice.securityModeCommand,
          eNB_indexP);
2670
        break;
2671

2672
      case DL_DCCH_MessageType__c1_PR_ueCapabilityEnquiry:
2673 2674 2675 2676 2677 2678 2679
        LOG_I(RRC, "[UE %d] Received Capability Enquiry (eNB %d)\n",
              ctxt_pP->module_id,
              eNB_indexP);
        rrc_ue_process_ueCapabilityEnquiry(
          ctxt_pP,
          &dl_dcch_msg->message.choice.c1.choice.ueCapabilityEnquiry,
          eNB_indexP);
2680
        break;
2681

2682 2683
      case DL_DCCH_MessageType__c1_PR_counterCheck:
        break;
winckel's avatar
RRC:  
winckel committed
2684

Cedric Roux's avatar
Cedric Roux committed
2685
#if defined(Rel10) || defined(Rel14)
2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699

      case DL_DCCH_MessageType__c1_PR_ueInformationRequest_r9:
        break;

      case DL_DCCH_MessageType__c1_PR_loggedMeasurementConfiguration_r10:
        break;

      case DL_DCCH_MessageType__c1_PR_rnReconfiguration_r10:
        break;
#endif

      case DL_DCCH_MessageType__c1_PR_spare1:
      case DL_DCCH_MessageType__c1_PR_spare2:
      case DL_DCCH_MessageType__c1_PR_spare3:
Cedric Roux's avatar
Cedric Roux committed
2700
#if !defined(Rel14)
2701
      case DL_DCCH_MessageType__c1_PR_spare4:
Cedric Roux's avatar
Cedric Roux committed
2702
#endif
2703 2704 2705 2706
        break;

      default:
        break;
2707
      }
2708
    }
2709
  }
2710

2711
#ifndef NO_RRM
2712
  send_msg(&S_rrc,msg_rrc_end_scan_req(ctxt_pP->module_id,eNB_indexP));
2713 2714 2715
#endif
}

2716
const char siWindowLength[8][5] = {"1ms","2ms","5ms","10ms","15ms","20ms","40ms","ERR"};
2717 2718
const char siWindowLength_int[7] = {1,2,5,10,15,20,40};

2719 2720
const char SIBType[12][6] = {"SIB3","SIB4","SIB5","SIB6","SIB7","SIB8","SIB9","SIB10","SIB11","SIB12","SIB13","Spare"};
const char SIBPeriod[8][6]= {"rf8","rf16","rf32","rf64","rf128","rf256","rf512","ERR"};
2721 2722
int siPeriod_int[7] = {80,160,320,640,1280,2560,5120};

2723
const char* SIBreserved( long value )
2724 2725 2726 2727 2728 2729 2730 2731 2732
{
  if (value < 0 || value > 1)
    return "ERR";

  if (value)
    return "notReserved";

  return "reserved";
}
2733
const char* SIBbarred( long value )
2734 2735 2736 2737 2738 2739 2740 2741 2742
{
  if (value < 0 || value > 1)
    return "ERR";

  if (value)
    return "notBarred";

  return "barred";
}
2743
const char* SIBallowed( long value )
2744 2745 2746 2747 2748 2749 2750 2751 2752
{
  if (value < 0 || value > 1)
    return "ERR";

  if (value)
    return "notAllowed";

  return "allowed";
}
2753
const char* SIB2SoundingPresent( int value )
2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767
{
  switch (value) {
  case SoundingRS_UL_ConfigCommon_PR_NOTHING:
    return "NOTHING";

  case SoundingRS_UL_ConfigCommon_PR_release:
    return "release";

  case SoundingRS_UL_ConfigCommon_PR_setup:
    return "setup";
  }

  return "ERR";
}
2768
const char* SIB2numberOfRA_Preambles( long value )
2769 2770 2771 2772 2773 2774
{
  static char temp[4] = {0};

  if (value < 0 || value > 15)
    return "ERR";

2775
  snprintf( temp, sizeof(temp), "n%ld", value*4 + 4 );
2776 2777 2778
  temp[3] = 0; // terminate string
  return temp;
}
2779
const char* SIB2powerRampingStep( long value )
2780 2781 2782 2783 2784 2785 2786
{
  if (value < 0 || value > 3)
    return "ERR";

  static const char str[4][4] = {"dB0","dB2","dB4","dB6"};
  return str[value];
}
2787
const char* SIB2preambleInitialReceivedTargetPower( long value )
2788 2789 2790 2791 2792 2793
{
  static char temp[8] = {0};

  if (value < 0 || value > 15)
    return "ERR";

2794
  snprintf( temp, sizeof(temp), "dBm-%ld", 120 - value*2 );
2795 2796 2797
  temp[7] = 0; // terminate string
  return temp;
}
2798
const char* SIB2preambleTransMax( long value )
2799 2800 2801 2802 2803 2804 2805
{
  static char temp[5] = {0};

  if (value < 0 || value > 10)
    return "ERR";

  if (value <= 5) {
2806
    snprintf( temp, sizeof(temp), "n%ld", value+3 );
2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
    return temp;
  }

  switch (value) {
  case 6:
    return "n10";

  case 7:
    return "n20";

  case 8:
    return "n50";

  case 9:
    return "n100";

  case 10:
    return "n200";
  }
Cedric Roux's avatar
Cedric Roux committed
2826 2827 2828

  /* unreachable but gcc warns... */
  return "ERR";
2829
}
2830
const char* SIB2ra_ResponseWindowSize( long value )
2831 2832 2833 2834 2835 2836 2837 2838 2839
{
  static char temp[4] = {0};

  if (value < 0 || value > 7)
    return "ERR";

  if (value == 7)
    return "sf10";

2840
  snprintf( temp, sizeof(temp), "sf%ld", value+2 );
2841 2842
  return temp;
}
2843
const char* SIB2mac_ContentionResolutionTimer( long value )
2844 2845 2846 2847 2848 2849
{
  static char temp[5] = {0};

  if (value < 0 || value > 7)
    return "ERR";

2850
  snprintf( temp, sizeof(temp), "sf%ld", 8 + value*8 );
2851 2852
  return temp;
}
2853
const char* SIB2modificationPeriodCoeff( long value )
2854
{
Cedric Roux's avatar
Cedric Roux committed
2855
  static char temp[32] = {0};
2856 2857 2858 2859 2860 2861 2862

  if (value < 0 || value > 3)
    return "ERR";

  snprintf( temp, sizeof(temp), "n%d", (int)pow(2,value+1) );
  return temp;
}
2863
const char* SIB2defaultPagingCycle( long value )
2864
{
Cedric Roux's avatar
Cedric Roux committed
2865
  static char temp[32] = {0};
2866 2867 2868 2869 2870 2871 2872

  if (value < 0 || value > 3)
    return "ERR";

  snprintf( temp, sizeof(temp), "rf%d", (int)pow(2,value+4) );
  return temp;
}
2873
const char* SIB2nB( long value )
2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884
{
  if (value < 0 || value > 7)
    return "ERR";

  static const char str[8][17] = {"fourT","twoT","oneT","halfT","quarterT","oneEigthT","oneSixteenthT","oneThirtySecondT"};
  return str[value];
}




2885
//-----------------------------------------------------------------------------
2886
int decode_BCCH_DLSCH_Message(
2887 2888 2889 2890 2891
  const protocol_ctxt_t* const ctxt_pP,
  const uint8_t                eNB_index,
  uint8_t*               const Sdu,
  const uint8_t                Sdu_len,
  const uint8_t                rsrq,
2892
  const uint8_t                rsrp )
Lionel Gauthier's avatar
Lionel Gauthier committed
2893
{
2894
  BCCH_DL_SCH_Message_t *bcch_message = NULL;
2895 2896
  SystemInformationBlockType1_t* sib1 = UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index];
  int i;
2897

2898
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_BCCH, VCD_FUNCTION_IN );
2899

2900 2901 2902 2903
  if (((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1) == 1) &&  // SIB1 received
      (UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIcnt == sib1->schedulingInfoList.list.count)) {
    // Avoid decoding  SystemInformationBlockType1_t* sib1 = UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index];
    // to prevent memory bloating
2904
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_BCCH, VCD_FUNCTION_OUT );
2905
    return 0;
2906
  }
2907

2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919
  rrc_set_sub_state( ctxt_pP->module_id, RRC_SUB_STATE_IDLE_RECEIVING_SIB );

  asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
                            &asn_DEF_BCCH_DL_SCH_Message,
                            (void **)&bcch_message,
                            (const void *)Sdu,
                            Sdu_len );

  if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
    LOG_E( RRC, "[UE %"PRIu8"] Failed to decode BCCH_DLSCH_MESSAGE (%zu bits)\n",
           ctxt_pP->module_id,
           dec_rval.consumed );
2920 2921 2922
    for (i=0;i<Sdu_len;i++)
      printf("%02x ",Sdu[i]);
    printf("\n");
2923 2924 2925 2926 2927
    // free the memory
    SEQUENCE_free( &asn_DEF_BCCH_DL_SCH_Message, (void*)bcch_message, 1 );
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_BCCH, VCD_FUNCTION_OUT );
    return -1;
  }
2928 2929

#if defined(ENABLE_ITTI)
2930
# if defined(DISABLE_ITTI_XER_PRINT)
2931 2932
  {
    MessageDef *msg_p;
2933

2934 2935
    msg_p = itti_alloc_new_message (TASK_RRC_UE, RRC_DL_BCCH_MESSAGE);
    memcpy (&msg_p->ittiMsg, (void *) bcch_message, sizeof(RrcDlBcchMessage));
2936

2937 2938
    itti_send_msg_to_task (TASK_UNKNOWN, ctxt_pP->instance, msg_p);
  }
2939
# else
2940 2941 2942
  {
    char        message_string[15000];
    size_t      message_string_size;
2943

2944 2945
    if ((message_string_size = xer_sprint(message_string, sizeof(message_string), &asn_DEF_BCCH_DL_SCH_Message, (void *)bcch_message)) > 0) {
      MessageDef *msg_p;
2946

2947 2948 2949
      msg_p = itti_alloc_new_message_sized (TASK_RRC_UE, RRC_DL_BCCH, message_string_size + sizeof (IttiMsgText));
      msg_p->ittiMsg.rrc_dl_bcch.size = message_string_size;
      memcpy(&msg_p->ittiMsg.rrc_dl_bcch.text, message_string, message_string_size);
winckel's avatar
winckel committed
2950

2951
      itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
2952
    }
2953
  }
2954
# endif
2955 2956
#endif

2957 2958 2959 2960 2961
  if (bcch_message->message.present == BCCH_DL_SCH_MessageType_PR_c1) {
    switch (bcch_message->message.choice.c1.present) {
    case BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1:
      if ((ctxt_pP->frame % 2) == 0) {
        // even frame
2962
        if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1) == 0) {
2963 2964 2965 2966 2967
          SystemInformationBlockType1_t* sib1 = UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index];
          memcpy( (void*)sib1,
                  (void*)&bcch_message->message.choice.c1.choice.systemInformationBlockType1,
                  sizeof(SystemInformationBlockType1_t) );
          LOG_D( RRC, "[UE %"PRIu8"] Decoding First SIB1\n", ctxt_pP->module_id );
2968 2969 2970

          LOG_I( RRC, "Panos-D: decode_BCCH_DLSCH_Message1 BEFORE decode_SIB1");
          //printf("Panos-D: decode_BCCH_DLSCH_Message1 BEFORE decode_SIB1");
2971
          decode_SIB1( ctxt_pP, eNB_index, rsrq, rsrp );
2972
        }
2973
      }
2974

2975
      break;
2976

2977
    case BCCH_DL_SCH_MessageType__c1_PR_systemInformation:
2978
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1) == 1) {
2979
        // SIB1 with schedulingInfoList is available
2980

2981 2982 2983 2984
        SystemInformation_t* si = UE_rrc_inst[ctxt_pP->module_id].si[eNB_index];
        memcpy( si,
                &bcch_message->message.choice.c1.choice.systemInformation,
                sizeof(SystemInformation_t) );
2985

2986 2987 2988
        LOG_D( RRC, "[UE %"PRIu8"] Decoding SI for frameP %"PRIu32"\n",
               ctxt_pP->module_id,
               ctxt_pP->frame );
2989 2990
        LOG_I( RRC, "Panos-D: decode_BCCH_DLSCH_Message1 BEFORE OTHER decode_SI");
        //printf("Panos-D: decode_BCCH_DLSCH_Message1 BEFORE OTHER decode_SI");
2991
        decode_SI( ctxt_pP, eNB_index );
2992
      }
2993 2994 2995 2996 2997 2998

      break;

    case BCCH_DL_SCH_MessageType__c1_PR_NOTHING:
    default:
      break;
2999
    }
3000
  }
winckel's avatar
winckel committed
3001

3002
  if ((rrc_get_sub_state(ctxt_pP->module_id) == RRC_SUB_STATE_IDLE_SIB_COMPLETE)
3003
#if defined(ENABLE_USE_MME)
3004
      && (UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.data != NULL)
3005
#endif
3006
     ) {
3007
    rrc_ue_generate_RRCConnectionRequest(ctxt_pP, 0);
3008
    rrc_set_sub_state( ctxt_pP->module_id, RRC_SUB_STATE_IDLE_CONNECTING );
winckel's avatar
winckel committed
3009 3010
  }

3011
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_BCCH, VCD_FUNCTION_OUT );
3012 3013

  return 0;
3014 3015
}

3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
//-----------------------------------------------------------------------------
int decode_PCCH_DLSCH_Message(
  const protocol_ctxt_t* const ctxt_pP,
  const uint8_t                eNB_index,
  uint8_t*               const Sdu,
  const uint8_t                Sdu_len)
{
  PCCH_Message_t *pcch_message = NULL;
  int i;

  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH, VCD_FUNCTION_IN );

  asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
                            &asn_DEF_PCCH_Message,
                            (void **)&pcch_message,
                            (const void *)Sdu,
                            Sdu_len );

  if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
    LOG_E( RRC, "[UE %"PRIu8"] Failed to decode PCCH_MESSAGE (%zu bits)\n",
           ctxt_pP->module_id,
           dec_rval.consumed );
    for (i=0;i<Sdu_len;i++)
      printf("%02x ",Sdu[i]);
    printf("\n");
    // free the memory
    SEQUENCE_free( &asn_DEF_PCCH_Message, (void*)pcch_message, 1 );
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH, VCD_FUNCTION_OUT );
    return -1;
  }

  return(0);
}
3049

3050
//-----------------------------------------------------------------------------
3051
int decode_SIB1( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index, const uint8_t rsrq, const uint8_t rsrp )
Lionel Gauthier's avatar
Lionel Gauthier committed
3052
{
3053
  SystemInformationBlockType1_t* sib1 = UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index];
3054

3055
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_UE_DECODE_SIB1, VCD_FUNCTION_IN );
3056

3057
  LOG_I( RRC, "[UE %d] : Dumping SIB 1\n", ctxt_pP->module_id );
3058

3059
  PLMN_Identity_t *PLMN_identity = &sib1->cellAccessRelatedInfo.plmn_IdentityList.list.array[0]->plmn_Identity;
3060

3061 3062 3063 3064
  int mccdigits = PLMN_identity->mcc->list.count;
  int mncdigits = PLMN_identity->mnc.list.count;

  int mcc;
3065

3066
  if (mccdigits == 2) {
3067 3068
    mcc = *PLMN_identity->mcc->list.array[0]*10 + *PLMN_identity->mcc->list.array[1];
  } else {
3069 3070
    mcc = *PLMN_identity->mcc->list.array[0]*100 + *PLMN_identity->mcc->list.array[1]*10 + *PLMN_identity->mcc->list.array[2];
  }
3071

3072 3073
  int mnc;

3074
  if (mncdigits == 2) {
3075
    mnc = *PLMN_identity->mnc.list.array[0]*10 + *PLMN_identity->mnc.list.array[1];
3076
  } else {
3077 3078
    mnc = *PLMN_identity->mnc.list.array[0]*100 + *PLMN_identity->mnc.list.array[1]*10 + *PLMN_identity->mnc.list.array[2];
  }
3079

3080 3081 3082 3083
  int tac = 0;

  if (sib1->cellAccessRelatedInfo.trackingAreaCode.size == 2) {
    tac = (sib1->cellAccessRelatedInfo.trackingAreaCode.buf[0]<<8) + sib1->cellAccessRelatedInfo.trackingAreaCode.buf[1];
3084
  }
3085

3086 3087 3088 3089 3090 3091
  LOG_I( RRC, "PLMN MCC %0*d, MNC %0*d, TAC 0x%04x\n", mccdigits, mcc, mncdigits, mnc, tac );
  long cellReservedForOperatorUse = sib1->cellAccessRelatedInfo.plmn_IdentityList.list.array[0]->cellReservedForOperatorUse;
  LOG_I( RRC, "cellReservedForOperatorUse                 : raw:%ld decoded:%s\n", cellReservedForOperatorUse, SIBreserved(cellReservedForOperatorUse) );

  // search internal table for provider name
  int plmn_ind = 0;
3092

3093 3094 3095
  while (plmn_data[plmn_ind].mcc > 0) {
    if ((plmn_data[plmn_ind].mcc == mcc) && (plmn_data[plmn_ind].mnc == mnc)) {
      LOG_I( RRC, "Found %s (name from internal table)\n", plmn_data[plmn_ind].oper_short );
3096 3097
      break;
    }
3098

3099 3100
    plmn_ind++;
  }
3101

3102 3103
  if (plmn_data[plmn_ind].mcc < 0) {
    LOG_I( RRC, "Found Unknown operator (no entry in internal table)\n" );
3104
  }
3105

3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124
  LOG_I( RRC, "cellAccessRelatedInfo.cellIdentity         : raw:%"PRIu32" decoded:%02x.%02x.%02x.%02x\n",
         BIT_STRING_to_uint32( &sib1->cellAccessRelatedInfo.cellIdentity ),
         sib1->cellAccessRelatedInfo.cellIdentity.buf[0],
         sib1->cellAccessRelatedInfo.cellIdentity.buf[1],
         sib1->cellAccessRelatedInfo.cellIdentity.buf[2],
         sib1->cellAccessRelatedInfo.cellIdentity.buf[3] >> sib1->cellAccessRelatedInfo.cellIdentity.bits_unused);

  long cellBarred = sib1->cellAccessRelatedInfo.cellBarred;
  LOG_I( RRC, "cellAccessRelatedInfo.cellBarred           : raw:%ld decoded:%s\n", cellBarred, SIBbarred(cellBarred) );
  long intraFreqReselection = sib1->cellAccessRelatedInfo.intraFreqReselection;
  LOG_I( RRC, "cellAccessRelatedInfo.intraFreqReselection : raw:%ld decoded:%s\n", intraFreqReselection, SIBallowed(intraFreqReselection) );
  LOG_I( RRC, "cellAccessRelatedInfo.csg_Indication       : %d\n", sib1->cellAccessRelatedInfo.csg_Indication );

  if (sib1->cellAccessRelatedInfo.csg_Identity)
    LOG_I( RRC, "cellAccessRelatedInfo.csg_Identity         : %"PRIu32"\n", BIT_STRING_to_uint32(sib1->cellAccessRelatedInfo.csg_Identity) );
  else
    LOG_I( RRC, "cellAccessRelatedInfo.csg_Identity         : not defined\n" );

  LOG_I( RRC, "cellSelectionInfo.q_RxLevMin               : %ld\n", sib1->cellSelectionInfo.q_RxLevMin );
3125

3126 3127 3128 3129
  if (sib1->cellSelectionInfo.q_RxLevMinOffset)
    LOG_I( RRC, "cellSelectionInfo.q_RxLevMinOffset         : %ld\n", *sib1->cellSelectionInfo.q_RxLevMinOffset );
  else
    LOG_I( RRC, "cellSelectionInfo.q_RxLevMinOffset         : not defined\n" );
3130

3131 3132 3133 3134
  if (sib1->p_Max)
    LOG_I( RRC, "p_Max                                      : %ld\n", *sib1->p_Max );
  else
    LOG_I( RRC, "p_Max                                      : not defined\n" );
3135

3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149
  LOG_I( RRC, "freqBandIndicator                          : %ld\n", sib1->freqBandIndicator );

  if (sib1->schedulingInfoList.list.count > 0) {
    for (int i=0; i<sib1->schedulingInfoList.list.count; i++) {
      LOG_I( RRC, "si_Periodicity[%d]                          : %s\n", i, SIBPeriod[min(sib1->schedulingInfoList.list.array[i]->si_Periodicity,7)]);

      if (sib1->schedulingInfoList.list.array[i]->sib_MappingInfo.list.count > 0) {
        char temp[32 * sizeof(SIBType[0])] = {0}; // maxSIB==32

        for (int j=0; j<sib1->schedulingInfoList.list.array[i]->sib_MappingInfo.list.count; j++) {
          sprintf( temp + j*sizeof(SIBType[0]), "%*s ", (int)sizeof(SIBType[0])-1, SIBType[min(*sib1->schedulingInfoList.list.array[i]->sib_MappingInfo.list.array[0],11)] );
        }

        LOG_I( RRC, "siSchedulingInfoSIBType[%d]                 : %s\n", i, temp );
3150
      } else {
3151
        LOG_I( RRC, "mapping list %d is null\n", i );
3152
      }
3153 3154
    }
  } else {
3155
    LOG_E( RRC, "siSchedulingInfoPeriod[0]                  : PROBLEM!!!\n" );
3156
    return -1;
3157 3158
  }

3159 3160 3161
  if (sib1->tdd_Config) {
    LOG_I( RRC, "TDD subframeAssignment                     : %ld\n", sib1->tdd_Config->subframeAssignment );
    LOG_I( RRC, "TDD specialSubframePatterns                : %ld\n", sib1->tdd_Config->specialSubframePatterns );
3162 3163
  }

3164 3165 3166 3167 3168
  LOG_I( RRC, "siWindowLength                             : %s\n", siWindowLength[min(sib1->si_WindowLength,7)] );
  LOG_I( RRC, "systemInfoValueTag                         : %ld\n", sib1->systemInfoValueTag );

  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIperiod     = siPeriod_int[sib1->schedulingInfoList.list.array[0]->si_Periodicity];
  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIwindowsize = siWindowLength_int[sib1->si_WindowLength];
3169
  LOG_I( RRC, "[FRAME unknown][RRC_UE][MOD %02"PRIu8"][][--- MAC_CONFIG_REQ (SIB1 params eNB %"PRIu8") --->][MAC_UE][MOD %02"PRIu8"][]\n",
3170 3171
         ctxt_pP->module_id, eNB_index, ctxt_pP->module_id );

3172 3173 3174
  rrc_mac_config_req_ue(ctxt_pP->module_id, 0, eNB_index,
			(RadioResourceConfigCommonSIB_t *)NULL,
			(struct PhysicalConfigDedicated *)NULL,
Cedric Roux's avatar
Cedric Roux committed
3175
#if defined(Rel10) || defined(Rel14)
3176 3177
			(SCellToAddMod_r10_t *)NULL,
			//(struct PhysicalConfigDedicatedSCell_r10 *)NULL,
3178
#endif
3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191
			(MeasObjectToAddMod_t **)NULL,
			(MAC_MainConfig_t *)NULL,
			0,
			(struct LogicalChannelConfig *)NULL,
			(MeasGapConfig_t *)NULL,
			UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index]->tdd_Config,
			(MobilityControlInfo_t *) NULL,
			&UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIwindowsize,
			&UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIperiod,
			NULL,
			NULL,
			NULL,
			(MBSFN_SubframeConfigList_t *)NULL
Cedric Roux's avatar
Cedric Roux committed
3192
#if defined(Rel10) || defined(Rel14)
3193 3194 3195
			,0,
			(MBSFN_AreaInfoList_r9_t *)NULL,
			(PMCH_InfoList_r9_t *)NULL
3196

3197 3198
#endif
#ifdef CBA
3199 3200 3201
			,
			0,
			0
3202 3203 3204
#endif
#if defined(Rel14)
           ,
3205
           0,
3206
           NULL,
3207
           NULL
3208
#endif
3209
			);
3210

3211
  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus = 1;
3212
  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIB1systemInfoValueTag = sib1->systemInfoValueTag;
3213 3214 3215 3216 3217

#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
  {
    int cell_valid = 0;

3218
    if (sib1->cellAccessRelatedInfo.cellBarred == SystemInformationBlockType1__cellAccessRelatedInfo__cellBarred_notBarred) {
3219 3220 3221 3222
      /* Cell is not barred */
      int plmn;
      int plmn_number;

3223
      plmn_number = sib1->cellAccessRelatedInfo.plmn_IdentityList.list.count;
3224 3225 3226 3227 3228

      /* Compare requested PLMN and PLMNs from SIB1*/
      for (plmn = 0; plmn < plmn_number; plmn++) {
        PLMN_Identity_t *plmn_Identity;

3229
        plmn_Identity = &sib1->cellAccessRelatedInfo.plmn_IdentityList.list.array[plmn]->plmn_Identity;
3230

3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251
        if (
          (
            (plmn_Identity->mcc == NULL)
            ||
            (
              (UE_rrc_inst[ctxt_pP->module_id].plmnID.MCCdigit1 == *(plmn_Identity->mcc->list.array[0])) &&
              (UE_rrc_inst[ctxt_pP->module_id].plmnID.MCCdigit2 == *(plmn_Identity->mcc->list.array[1])) &&
              (UE_rrc_inst[ctxt_pP->module_id].plmnID.MCCdigit3 == *(plmn_Identity->mcc->list.array[2]))
            )
          )
          &&
          (UE_rrc_inst[ctxt_pP->module_id].plmnID.MNCdigit1 == *(plmn_Identity->mnc.list.array[0]))
          &&
          (UE_rrc_inst[ctxt_pP->module_id].plmnID.MNCdigit2 == *(plmn_Identity->mnc.list.array[1]))
          &&
          (
            ((UE_rrc_inst[ctxt_pP->module_id].plmnID.MNCdigit3 == 0xf) && (plmn_Identity->mnc.list.count == 2))
            ||
            (UE_rrc_inst[ctxt_pP->module_id].plmnID.MNCdigit3 == *(plmn_Identity->mnc.list.array[2]))
          )
        ) {
3252 3253 3254 3255 3256
          /* PLMN match, send a confirmation to NAS */
          MessageDef  *msg_p;

          msg_p = itti_alloc_new_message(TASK_RRC_UE, NAS_CELL_SELECTION_CNF);
          NAS_CELL_SELECTION_CNF (msg_p).errCode = AS_SUCCESS;
3257 3258
          NAS_CELL_SELECTION_CNF (msg_p).cellID = BIT_STRING_to_uint32(&sib1->cellAccessRelatedInfo.cellIdentity);
          NAS_CELL_SELECTION_CNF (msg_p).tac = BIT_STRING_to_uint16(&sib1->cellAccessRelatedInfo.trackingAreaCode);
3259 3260 3261 3262
          NAS_CELL_SELECTION_CNF (msg_p).rat = 0xFF;
          NAS_CELL_SELECTION_CNF (msg_p).rsrq = rsrq;
          NAS_CELL_SELECTION_CNF (msg_p).rsrp = rsrp;

3263
          itti_send_msg_to_task(TASK_NAS_UE, ctxt_pP->instance, msg_p);
3264 3265
          cell_valid = 1;
          break;
3266
        }
3267
      }
3268 3269
    }

3270 3271 3272
    if (cell_valid == 0) {
      /* Cell can not be used, ask PHY to try the next one */
      MessageDef  *msg_p;
3273

3274
      msg_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_NEXT_CELL_REQ);
3275

3276
      itti_send_msg_to_task(TASK_PHY_UE, ctxt_pP->instance, msg_p);
3277
    }
3278 3279 3280
  }
#endif

3281
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_UE_DECODE_SIB1, VCD_FUNCTION_OUT );
3282

3283
  return 0;
3284 3285 3286
}


3287
//-----------------------------------------------------------------------------
3288
 void dump_sib2( SystemInformationBlockType2_t *sib2 )
Lionel Gauthier's avatar
Lionel Gauthier committed
3289
{
3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331
  // ac_BarringInfo
  if (sib2->ac_BarringInfo) {
    LOG_I( RRC, "ac_BarringInfo->ac_BarringForEmergency : %d\n",
           sib2->ac_BarringInfo->ac_BarringForEmergency );

    if (sib2->ac_BarringInfo->ac_BarringForMO_Signalling) {
      LOG_I( RRC, "ac_BarringInfo->ac_BarringForMO_Signalling->ac_BarringFactor       : %ld\n",
             sib2->ac_BarringInfo->ac_BarringForMO_Signalling->ac_BarringFactor );
      LOG_I( RRC, "ac_BarringInfo->ac_BarringForMO_Signalling->ac_BarringTime         : %ld\n",
             sib2->ac_BarringInfo->ac_BarringForMO_Signalling->ac_BarringTime );
      LOG_I( RRC, "ac_BarringInfo->ac_BarringForMO_Signalling->ac_BarringForSpecialAC : %"PRIu32"\n",
             BIT_STRING_to_uint32(&sib2->ac_BarringInfo->ac_BarringForMO_Signalling->ac_BarringForSpecialAC) );
    } else
      LOG_I( RRC, "ac_BarringInfo->ac_BarringForMO_Signalling : not defined\n" );

    if (sib2->ac_BarringInfo->ac_BarringForMO_Data) {
      LOG_I( RRC, "ac_BarringInfo->ac_BarringForMO_Data->ac_BarringFactor       : %ld\n",
             sib2->ac_BarringInfo->ac_BarringForMO_Data->ac_BarringFactor );
      LOG_I( RRC, "ac_BarringInfo->ac_BarringForMO_Data->ac_BarringTime         : %ld\n",
             sib2->ac_BarringInfo->ac_BarringForMO_Data->ac_BarringTime );
      LOG_I( RRC, "ac_BarringInfo->ac_BarringForMO_Data->ac_BarringForSpecialAC : %"PRIu32"\n",
             BIT_STRING_to_uint32(&sib2->ac_BarringInfo->ac_BarringForMO_Data->ac_BarringForSpecialAC) );
    } else
      LOG_I( RRC, "ac_BarringInfo->ac_BarringForMO_Data : not defined\n" );
  } else
    LOG_I( RRC, "ac_BarringInfo : not defined\n" );

  // RACH
  LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.numberOfRA_Preambles  : raw:%ld decoded:%s\n",
         sib2->radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.numberOfRA_Preambles,
         SIB2numberOfRA_Preambles(sib2->radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.numberOfRA_Preambles) );

  if (sib2->radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.preamblesGroupAConfig) {
    LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.preamblesGroupAConfig->sizeOfRA_PreamblesGroupA : %ld\n",
           sib2->radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.preamblesGroupAConfig->sizeOfRA_PreamblesGroupA );
    LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.preamblesGroupAConfig->messageSizeGroupA        : %ld\n",
           sib2->radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.preamblesGroupAConfig->messageSizeGroupA );
    LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.preamblesGroupAConfig->messagePowerOffsetGroupB : %ld\n",
           sib2->radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.preamblesGroupAConfig->messagePowerOffsetGroupB );
  } else {
    LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.preambleInfo.preamblesGroupAConfig : not defined\n" );
  }
3332

3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376
  LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.powerRampingParameters.powerRampingStep                   : raw:%ld decoded:%s\n",
         sib2->radioResourceConfigCommon.rach_ConfigCommon.powerRampingParameters.powerRampingStep,
         SIB2powerRampingStep(sib2->radioResourceConfigCommon.rach_ConfigCommon.powerRampingParameters.powerRampingStep) );
  LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.powerRampingParameters.preambleInitialReceivedTargetPower : raw:%ld decoded:%s\n",
         sib2->radioResourceConfigCommon.rach_ConfigCommon.powerRampingParameters.preambleInitialReceivedTargetPower,
         SIB2preambleInitialReceivedTargetPower(sib2->radioResourceConfigCommon.rach_ConfigCommon.powerRampingParameters.preambleInitialReceivedTargetPower) );

  LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.ra_SupervisionInfo.preambleTransMax              : raw:%ld decoded:%s\n",
         sib2->radioResourceConfigCommon.rach_ConfigCommon.ra_SupervisionInfo.preambleTransMax,
         SIB2preambleTransMax(sib2->radioResourceConfigCommon.rach_ConfigCommon.ra_SupervisionInfo.preambleTransMax) );
  LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.ra_SupervisionInfo.ra_ResponseWindowSize         : raw:%ld decoded:%s\n",
         sib2->radioResourceConfigCommon.rach_ConfigCommon.ra_SupervisionInfo.ra_ResponseWindowSize,
         SIB2ra_ResponseWindowSize(sib2->radioResourceConfigCommon.rach_ConfigCommon.ra_SupervisionInfo.ra_ResponseWindowSize) );
  LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.ra_SupervisionInfo.mac_ContentionResolutionTimer : raw:%ld decoded:%s\n",
         sib2->radioResourceConfigCommon.rach_ConfigCommon.ra_SupervisionInfo.mac_ContentionResolutionTimer,
         SIB2mac_ContentionResolutionTimer(sib2->radioResourceConfigCommon.rach_ConfigCommon.ra_SupervisionInfo.mac_ContentionResolutionTimer) );

  LOG_I( RRC, "radioResourceConfigCommon.rach_ConfigCommon.maxHARQ_Msg3Tx : %ld\n",
         sib2->radioResourceConfigCommon.rach_ConfigCommon.maxHARQ_Msg3Tx );

  // BCCH
  LOG_I( RRC, "radioResourceConfigCommon.bcch_Config.modificationPeriodCoeff : raw:%ld decoded:%s\n",
         sib2->radioResourceConfigCommon.bcch_Config.modificationPeriodCoeff,
         SIB2modificationPeriodCoeff(sib2->radioResourceConfigCommon.bcch_Config.modificationPeriodCoeff) );

  // PCCH
  LOG_I( RRC, "radioResourceConfigCommon.pcch_Config.defaultPagingCycle : raw:%ld decoded:%s\n",
         sib2->radioResourceConfigCommon.pcch_Config.defaultPagingCycle,
         SIB2defaultPagingCycle(sib2->radioResourceConfigCommon.pcch_Config.defaultPagingCycle) );
  LOG_I( RRC, "radioResourceConfigCommon.pcch_Config.nB                 : raw:%ld decoded:%s\n",
         sib2->radioResourceConfigCommon.pcch_Config.nB,
         SIB2nB(sib2->radioResourceConfigCommon.pcch_Config.nB) );

  // PRACH
  LOG_I( RRC, "radioResourceConfigCommon.prach_Config.rootSequenceIndex                          : %ld\n",
         sib2->radioResourceConfigCommon.prach_Config.rootSequenceIndex );
  LOG_I( RRC, "radioResourceConfigCommon.prach_Config.prach_ConfigInfo.prach_ConfigIndex         : %ld\n",
         sib2->radioResourceConfigCommon.prach_Config.prach_ConfigInfo.prach_ConfigIndex );
  LOG_I( RRC, "radioResourceConfigCommon.prach_Config.prach_ConfigInfo.highSpeedFlag             : %d\n",
         sib2->radioResourceConfigCommon.prach_Config.prach_ConfigInfo.highSpeedFlag );
  LOG_I( RRC, "radioResourceConfigCommon.prach_Config.prach_ConfigInfo.zeroCorrelationZoneConfig : %ld\n",
         sib2->radioResourceConfigCommon.prach_Config.prach_ConfigInfo.zeroCorrelationZoneConfig );
  LOG_I( RRC, "radioResourceConfigCommon.prach_Config.prach_ConfigInfo.prach_FreqOffset          : %ld\n",
         sib2->radioResourceConfigCommon.prach_Config.prach_ConfigInfo.prach_FreqOffset );
3377

3378 3379 3380 3381 3382
  // PDSCH-Config
  LOG_I( RRC, "radioResourceConfigCommon.pdsch_ConfigCommon.referenceSignalPower : %ld\n",
         sib2->radioResourceConfigCommon.pdsch_ConfigCommon.referenceSignalPower );
  LOG_I( RRC, "radioResourceConfigCommon.pdsch_ConfigCommon.p_b                  : %ld\n",
         sib2->radioResourceConfigCommon.pdsch_ConfigCommon.p_b );
3383

3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400
  // PUSCH-Config
  LOG_I( RRC, "radioResourceConfigCommon.pusch_ConfigCommon.pusch_ConfigBasic.n_SB                : %ld\n",
         sib2->radioResourceConfigCommon.pusch_ConfigCommon.pusch_ConfigBasic.n_SB );
  LOG_I( RRC, "radioResourceConfigCommon.pusch_ConfigCommon.pusch_ConfigBasic.hoppingMode         : %ld\n",
         sib2->radioResourceConfigCommon.pusch_ConfigCommon.pusch_ConfigBasic.hoppingMode );
  LOG_I( RRC, "radioResourceConfigCommon.pusch_ConfigCommon.pusch_ConfigBasic.pusch_HoppingOffset : %ld\n",
         sib2->radioResourceConfigCommon.pusch_ConfigCommon.pusch_ConfigBasic.pusch_HoppingOffset );
  LOG_I( RRC, "radioResourceConfigCommon.pusch_ConfigCommon.pusch_ConfigBasic.enable64QAM         : %d\n",
         sib2->radioResourceConfigCommon.pusch_ConfigCommon.pusch_ConfigBasic.enable64QAM );
  LOG_I( RRC, "radioResourceConfigCommon.pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupHoppingEnabled    : %d\n",
         sib2->radioResourceConfigCommon.pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupHoppingEnabled );
  LOG_I( RRC, "radioResourceConfigCommon.pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH   : %ld\n",
         sib2->radioResourceConfigCommon.pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH );
  LOG_I( RRC, "radioResourceConfigCommon.pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled : %d\n",
         sib2->radioResourceConfigCommon.pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled );
  LOG_I( RRC, "radioResourceConfigCommon.pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.cyclicShift            : %ld\n",
         sib2->radioResourceConfigCommon.pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.cyclicShift );
3401

3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423
  // PUCCH-Config
  LOG_I( RRC, "radioResourceConfigCommon.pucch_ConfigCommon.deltaPUCCH_Shift : %ld\n",
         sib2->radioResourceConfigCommon.pucch_ConfigCommon.deltaPUCCH_Shift );
  LOG_I( RRC, "radioResourceConfigCommon.pucch_ConfigCommon.nRB_CQI          : %ld\n",
         sib2->radioResourceConfigCommon.pucch_ConfigCommon.nRB_CQI );
  LOG_I( RRC, "radioResourceConfigCommon.pucch_ConfigCommon.nCS_AN           : %ld\n",
         sib2->radioResourceConfigCommon.pucch_ConfigCommon.nCS_AN );
  LOG_I( RRC, "radioResourceConfigCommon.pucch_ConfigCommon.n1PUCCH_AN       : %ld\n",
         sib2->radioResourceConfigCommon.pucch_ConfigCommon.n1PUCCH_AN );

  // SoundingRS_UL_Config
  LOG_I( RRC, "radioResourceConfigCommon.soundingRS_UL_ConfigCommon.present : raw:%d decoded:%s\n",
         sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.present,
         SIB2SoundingPresent(sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.present) );

  if (sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.present == SoundingRS_UL_ConfigCommon_PR_setup) {
    LOG_I( RRC, "radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_BandwidthConfig                 : %ld\n",
           sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_BandwidthConfig );
    LOG_I( RRC, "radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_SubframeConfig                  : %ld\n",
           sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_SubframeConfig );
    LOG_I( RRC, "radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.ackNackSRS_SimultaneousTransmission : %d\n",
           sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.ackNackSRS_SimultaneousTransmission );
3424 3425 3426 3427 3428 3429 3430

    if(sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts)
    {
    LOG_I( RRC, "radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts                        : %ld\n",
           /* TODO: check that it's okay to access [0] */
           sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts[0] );
    }
3431
  }
3432

3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454
  // uplinkPowerControlCommon
  LOG_I( RRC, "radioResourceConfigCommon.uplinkPowerControlCommon.p0_NominalPUSCH   : %ld\n",
         sib2->radioResourceConfigCommon.uplinkPowerControlCommon.p0_NominalPUSCH );
  LOG_I( RRC, "radioResourceConfigCommon.uplinkPowerControlCommon.alpha             : %ld\n",
         sib2->radioResourceConfigCommon.uplinkPowerControlCommon.alpha );
  LOG_I( RRC, "radioResourceConfigCommon.uplinkPowerControlCommon.p0_NominalPUCCH   : %ld\n",
         sib2->radioResourceConfigCommon.uplinkPowerControlCommon.p0_NominalPUCCH );
  LOG_I( RRC, "radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1  : %ld\n",
         sib2->radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1 );
  LOG_I( RRC, "radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1b : %ld\n",
         sib2->radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1b );
  LOG_I( RRC, "radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2  : %ld\n",
         sib2->radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2 );
  LOG_I( RRC, "radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2a : %ld\n",
         sib2->radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2a );
  LOG_I( RRC, "radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2b : %ld\n",
         sib2->radioResourceConfigCommon.uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2b );
  LOG_I( RRC, "radioResourceConfigCommon.uplinkPowerControlCommon.deltaPreambleMsg3 : %ld\n",
         sib2->radioResourceConfigCommon.uplinkPowerControlCommon.deltaPreambleMsg3 );

  LOG_I( RRC, "radioResourceConfigCommon.ul_CyclicPrefixLength : %ld\n",
         sib2->radioResourceConfigCommon.ul_CyclicPrefixLength );
3455

Cedric Roux's avatar
Cedric Roux committed
3456
#if defined(Rel10) || defined(Rel14)
3457 3458 3459
  // UplinkPowerControlCommon_v1020
  // ...
#endif
3460

3461 3462 3463 3464 3465 3466
  LOG_I( RRC, "ue_TimersAndConstants.t300 : %ld\n", sib2->ue_TimersAndConstants.t300 );
  LOG_I( RRC, "ue_TimersAndConstants.t301 : %ld\n", sib2->ue_TimersAndConstants.t301 );
  LOG_I( RRC, "ue_TimersAndConstants.t310 : %ld\n", sib2->ue_TimersAndConstants.t310 );
  LOG_I( RRC, "ue_TimersAndConstants.n310 : %ld\n", sib2->ue_TimersAndConstants.n310 );
  LOG_I( RRC, "ue_TimersAndConstants.t311 : %ld\n", sib2->ue_TimersAndConstants.t311 );
  LOG_I( RRC, "ue_TimersAndConstants.n311 : %ld\n", sib2->ue_TimersAndConstants.n311 );
3467

3468 3469 3470 3471
  if (sib2->freqInfo.ul_CarrierFreq)
    LOG_I( RRC, "freqInfo.ul_CarrierFreq             : %ld\n", *sib2->freqInfo.ul_CarrierFreq );
  else
    LOG_I( RRC, "freqInfo.ul_CarrierFreq             : not defined\n" );
3472

3473 3474 3475 3476
  if (sib2->freqInfo.ul_Bandwidth)
    LOG_I( RRC, "freqInfo.ul_Bandwidth               : %ld\n", *sib2->freqInfo.ul_Bandwidth );
  else
    LOG_I( RRC, "freqInfo.ul_Bandwidth               : not defined\n" );
3477

3478
  LOG_I( RRC, "freqInfo.additionalSpectrumEmission : %ld\n", sib2->freqInfo.additionalSpectrumEmission );
3479

3480 3481 3482 3483 3484
  if (sib2->mbsfn_SubframeConfigList) {
    LOG_I( RRC, "mbsfn_SubframeConfigList : %p\n", sib2->mbsfn_SubframeConfigList );
    // FIXME
  } else
    LOG_I( RRC, "mbsfn_SubframeConfigList : not defined\n" );
3485

3486
  LOG_I( RRC, "timeAlignmentTimerCommon : %ld\n", sib2->timeAlignmentTimerCommon );
3487

Cedric Roux's avatar
Cedric Roux committed
3488
#if defined(Rel10) || defined(Rel14)
3489

3490 3491 3492 3493 3494
  if (sib2->lateNonCriticalExtension) {
    LOG_I( RRC, "lateNonCriticalExtension : %p\n", sib2->lateNonCriticalExtension );
  } else
    LOG_I( RRC, "lateNonCriticalExtension : not defined\n" );

3495
  if (sib2->ext1 && sib2->ext1->ssac_BarringForMMTEL_Voice_r9) {
3496
    LOG_I( RRC, "ssac_BarringForMMTEL_Voice_r9->ac_BarringFactor       : %ld\n",
3497
           sib2->ext1->ssac_BarringForMMTEL_Voice_r9->ac_BarringFactor );
3498
    LOG_I( RRC, "ssac_BarringForMMTEL_Voice_r9->ac_BarringTime         : %ld\n",
3499
           sib2->ext1->ssac_BarringForMMTEL_Voice_r9->ac_BarringTime );
3500
    LOG_I( RRC, "ssac_BarringForMMTEL_Voice_r9->ac_BarringForSpecialAC : %"PRIu32"\n",
3501
           BIT_STRING_to_uint32(&sib2->ext1->ssac_BarringForMMTEL_Voice_r9->ac_BarringForSpecialAC) );
3502 3503 3504
  } else
    LOG_I( RRC, "ssac_BarringForMMTEL_Voice_r9 : not defined\n" );

3505
  if (sib2->ext1 && sib2->ext1->ssac_BarringForMMTEL_Video_r9) {
3506
    LOG_I( RRC, "ssac_BarringForMMTEL_Video_r9->ac_BarringFactor       : %ld\n",
3507
           sib2->ext1->ssac_BarringForMMTEL_Video_r9->ac_BarringFactor );
3508
    LOG_I( RRC, "ssac_BarringForMMTEL_Video_r9->ac_BarringTime         : %ld\n",
3509
           sib2->ext1->ssac_BarringForMMTEL_Video_r9->ac_BarringTime );
3510
    LOG_I( RRC, "ssac_BarringForMMTEL_Video_r9->ac_BarringForSpecialAC : %"PRIu32"\n",
3511
           BIT_STRING_to_uint32(&sib2->ext1->ssac_BarringForMMTEL_Video_r9->ac_BarringForSpecialAC) );
3512 3513 3514
  } else
    LOG_I( RRC, "ssac_BarringForMMTEL_Video_r9 : not defined\n" );

3515
  if (sib2->ext2 && sib2->ext2->ac_BarringForCSFB_r10) {
3516
    LOG_I( RRC, "ac_BarringForCSFB_r10->ac_BarringFactor       : %ld\n",
3517
           sib2->ext2->ac_BarringForCSFB_r10->ac_BarringFactor );
3518
    LOG_I( RRC, "ac_BarringForCSFB_r10->ac_BarringTime         : %ld\n",
3519
           sib2->ext2->ac_BarringForCSFB_r10->ac_BarringTime );
3520
    LOG_I( RRC, "ac_BarringForCSFB_r10->ac_BarringForSpecialAC : %"PRIu32"\n",
3521
           BIT_STRING_to_uint32(&sib2->ext2->ac_BarringForCSFB_r10->ac_BarringForSpecialAC) );
3522 3523
  } else
    LOG_I( RRC, "ac_BarringForCSFB_r10 : not defined\n" );
3524

3525
#endif
3526 3527
}

3528
//-----------------------------------------------------------------------------
3529
 void dump_sib3( SystemInformationBlockType3_t *sib3 )
3530
{
3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574
  LOG_I( RRC, "Dumping SIB3 (see TS36.331 V8.21.0)\n" );

  int q_Hyst_dB = sib3->cellReselectionInfoCommon.q_Hyst; // sib3->cellReselectionInfoCommon.q_Hyst is a enumerated value

  if (q_Hyst_dB > 6)
    q_Hyst_dB = (q_Hyst_dB-6) * 2 + 6;

  LOG_I( RRC, "cellReselectionInfoCommon.q_Hyst : raw:%ld  decoded:%d dB\n", sib3->cellReselectionInfoCommon.q_Hyst, q_Hyst_dB );

  if (sib3->cellReselectionInfoCommon.speedStateReselectionPars) {
    LOG_I( RRC, "cellReselectionInfoCommon.speedStateReselectionPars->mobilityStateParameters.t_Evaluation : %ld\n",
           sib3->cellReselectionInfoCommon.speedStateReselectionPars->mobilityStateParameters.t_Evaluation );
    LOG_I( RRC, "cellReselectionInfoCommon.speedStateReselectionPars->mobilityStateParameters.t_HystNormal : %ld\n",
           sib3->cellReselectionInfoCommon.speedStateReselectionPars->mobilityStateParameters.t_HystNormal );
    LOG_I( RRC, "cellReselectionInfoCommon.speedStateReselectionPars->mobilityStateParameters.n_CellChangeMedium : %ld\n",
           sib3->cellReselectionInfoCommon.speedStateReselectionPars->mobilityStateParameters.n_CellChangeMedium );
    LOG_I( RRC, "cellReselectionInfoCommon.speedStateReselectionPars->mobilityStateParameters.n_CellChangeHigh : %ld\n",
           sib3->cellReselectionInfoCommon.speedStateReselectionPars->mobilityStateParameters.n_CellChangeHigh );
    int q_HystSF_Medium = 6 - 2 * sib3->cellReselectionInfoCommon.speedStateReselectionPars->q_HystSF.sf_Medium;
    int q_HystSF_High = 6 - 2 * sib3->cellReselectionInfoCommon.speedStateReselectionPars->q_HystSF.sf_High;
    LOG_I( RRC, "cellReselectionInfoCommon.speedStateReselectionPars->q_HystSF.sf_Medium : raw:%ld decoded:%d dB\n", sib3->cellReselectionInfoCommon.speedStateReselectionPars->q_HystSF.sf_Medium,
           q_HystSF_Medium );
    LOG_I( RRC, "cellReselectionInfoCommon.speedStateReselectionPars->q_HystSF.sf_High : raw:%ld decoded:%d dB\n", sib3->cellReselectionInfoCommon.speedStateReselectionPars->q_HystSF.sf_High,
           q_HystSF_High );
  } else {
    LOG_I( RRC, "cellReselectionInfoCommon.speedStateReselectionPars : not defined\n" );
  }

  if (sib3->cellReselectionServingFreqInfo.s_NonIntraSearch) {
    LOG_I( RRC, "cellReselectionServingFreqInfo.s_NonIntraSearch : %ld\n", *(sib3->cellReselectionServingFreqInfo.s_NonIntraSearch) );
  } else {
    LOG_I( RRC, "cellReselectionServingFreqInfo.s_NonIntraSearch : not defined\n" );
  }

  LOG_I( RRC, "cellReselectionServingFreqInfo.threshServingLow : %ld\n", sib3->cellReselectionServingFreqInfo.threshServingLow );
  LOG_I( RRC, "cellReselectionServingFreqInfo.cellReselectionPriority : %ld\n", sib3->cellReselectionServingFreqInfo.cellReselectionPriority );

  LOG_I( RRC, "intraFreqCellReselectionInfo.q_RxLevMin : %ld\n", sib3->intraFreqCellReselectionInfo.q_RxLevMin );

  if (sib3->intraFreqCellReselectionInfo.p_Max) {
    LOG_I( RRC, "intraFreqCellReselectionInfo.p_Max : %ld\n", *(sib3->intraFreqCellReselectionInfo.p_Max) );
  } else {
    LOG_I( RRC, "intraFreqCellReselectionInfo.p_Max : not defined\n" );
  }
3575

3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597
  if (sib3->intraFreqCellReselectionInfo.s_IntraSearch) {
    LOG_I( RRC, "intraFreqCellReselectionInfo.s_IntraSearch : %ld\n", *(sib3->intraFreqCellReselectionInfo.s_IntraSearch) );
  } else {
    LOG_I( RRC, "intraFreqCellReselectionInfo.s_IntraSearch : not defined\n" );
  }

  if (sib3->intraFreqCellReselectionInfo.allowedMeasBandwidth) {
    LOG_I( RRC, "intraFreqCellReselectionInfo.allowedMeasBandwidth : %ld\n", *(sib3->intraFreqCellReselectionInfo.allowedMeasBandwidth) );
  } else {
    LOG_I( RRC, "intraFreqCellReselectionInfo.allowedMeasBandwidth : not defined\n" );
  }

  LOG_I( RRC, "intraFreqCellReselectionInfo.presenceAntennaPort1 : %d\n", sib3->intraFreqCellReselectionInfo.presenceAntennaPort1 );
  LOG_I( RRC, "intraFreqCellReselectionInfo.neighCellConfig : %"PRIu8"\n", BIT_STRING_to_uint8( &(sib3->intraFreqCellReselectionInfo.neighCellConfig) ) );
  LOG_I( RRC, "intraFreqCellReselectionInfo.t_ReselectionEUTRA : %ld\n", sib3->intraFreqCellReselectionInfo.t_ReselectionEUTRA );

  if (sib3->intraFreqCellReselectionInfo.t_ReselectionEUTRA_SF) {
    LOG_I( RRC, "intraFreqCellReselectionInfo.t_ReselectionEUTRA_SF->sf_Medium : %ld\n", sib3->intraFreqCellReselectionInfo.t_ReselectionEUTRA_SF->sf_Medium );
    LOG_I( RRC, "intraFreqCellReselectionInfo.t_ReselectionEUTRA_SF->sf_High : %ld\n", sib3->intraFreqCellReselectionInfo.t_ReselectionEUTRA_SF->sf_High );
  } else {
    LOG_I( RRC, "intraFreqCellReselectionInfo.t_ReselectionEUTRA_SF : not defined\n" );
  }
3598 3599
}

3600 3601 3602 3603
int Qoffsettab[31] = {-24,-22,-20,-18,-16,-14,-12,-10,-8,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,8,10,12,14,16,18,20,22,24};
int PhysCellIdRange[16] = {4,8,12,16,24,32,48,64,84,96,128,168,252,504,0,0};

uint64_t arfcn_to_freq(long arfcn) {
3604

3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637
  if (arfcn < 600)  // Band 1
    return((uint64_t)2110000000 + (arfcn*100000));
  else if (arfcn <1200) // Band 2
    return((uint64_t)1930000000 + ((arfcn-600)*100000));
  else if (arfcn <1950) // Band 3
    return((uint64_t)1805000000 + ((arfcn-1200)*100000));
  else if (arfcn <2400) // Band 4
    return((uint64_t)2110000000 + ((arfcn-1950)*100000));
  else if (arfcn <2650) // Band 5
    return((uint64_t)869000000 + ((arfcn-2400)*100000));
  else if (arfcn <2750) // Band 6
    return((uint64_t)875000000 + ((arfcn-2650)*100000));
  else if (arfcn <3450) // Band 7
    return((uint64_t)2620000000 + ((arfcn-2750)*100000));
  else if (arfcn <3800) // Band 8
    return((uint64_t)925000000 + ((arfcn-3450)*100000));
  else if (arfcn <4150) // Band 9
    return((uint64_t)1844900000 + ((arfcn-3800)*100000));
  else if (arfcn <4650) // Band 10
    return((uint64_t)2110000000 + ((arfcn-4150)*100000));
  else if (arfcn <5010) // Band 11
    return((uint64_t)1475900000 + ((arfcn-4750)*100000));
  else if (arfcn <5180) // Band 12
    return((uint64_t)729000000 + ((arfcn-5010)*100000));
  else if (arfcn <5280) // Band 13
    return((uint64_t)746000000 + ((arfcn-5180)*100000));
  else if (arfcn <5730) // Band 14
    return((uint64_t)758000000 + ((arfcn-5280)*100000));
  else if (arfcn <5850) // Band 17
    return((uint64_t)734000000 + ((arfcn-5730)*100000));
  else if (arfcn <6000) // Band 18
    return((uint64_t)860000000 + ((arfcn-5850)*100000));
  else if (arfcn <6150) // Band 19
3638
    return((uint64_t)875000000 + ((arfcn-6000)*100000));
3639
  else if (arfcn <6450) // Band 20
3640
    return((uint64_t)791000000 + ((arfcn-6150)*100000));
3641
  else if (arfcn <6600) // Band 21
3642
    return((uint64_t)1495900000 + ((arfcn-6450)*100000));
3643
  else if (arfcn <7500) // Band 22
3644
    return((uint64_t)351000000 + ((arfcn-6600)*100000));
3645
  else if (arfcn <7700) // Band 23
3646
    return((uint64_t)2180000000 + ((arfcn-7500)*100000));
3647
  else if (arfcn <8040) // Band 24
3648
    return((uint64_t)1525000000 + ((arfcn-7700)*100000));
3649
  else if (arfcn <8690) // Band 25
3650
    return((uint64_t)1930000000 + ((arfcn-8040)*100000));
3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672
  else if (arfcn <36200) // Band 33
    return((uint64_t)1900000000 + ((arfcn-36000)*100000));
  else if (arfcn <36350) // Band 34
    return((uint64_t)2010000000 + ((arfcn-36200)*100000));
  else if (arfcn <36950) // Band 35
    return((uint64_t)1850000000 + ((arfcn-36350)*100000));
  else if (arfcn <37550) // Band 36
    return((uint64_t)1930000000 + ((arfcn-36950)*100000));
  else if (arfcn <37750) // Band 37
    return((uint64_t)1910000000 + ((arfcn-37550)*100000));
  else if (arfcn <38250) // Band 38
    return((uint64_t)2570000000 + ((arfcn-37750)*100000));
  else if (arfcn <38650) // Band 39
    return((uint64_t)1880000000 + ((arfcn-38250)*100000));
  else if (arfcn <39650) // Band 40
    return((uint64_t)2300000000 + ((arfcn-38650)*100000));
  else if (arfcn <41590) // Band 41
    return((uint64_t)2496000000 + ((arfcn-39650)*100000));
  else if (arfcn <43590) // Band 42
    return((uint64_t)3400000000 + ((arfcn-41590)*100000));
  else if (arfcn <45590) // Band 43
    return((uint64_t)3600000000 + ((arfcn-43950)*100000));
Cedric Roux's avatar
Cedric Roux committed
3673
  else {
Cedric Roux's avatar
Cedric Roux committed
3674
    LOG_E(RRC,"Unknown EARFCN %ld\n",arfcn);
Cedric Roux's avatar
Cedric Roux committed
3675 3676
    exit(1);
  }
3677
}
3678
 void dump_sib5( SystemInformationBlockType5_t *sib5 )
3679 3680
{
  InterFreqCarrierFreqList_t interFreqCarrierFreqList = sib5->interFreqCarrierFreqList;
3681
  int i,j;
3682 3683 3684
  InterFreqCarrierFreqInfo_t *ifcfInfo;

  LOG_I( RRC, "Dumping SIB5 (see TS36.331 V8.21.0)\n" );
3685

3686 3687 3688
  for (i=0;i<interFreqCarrierFreqList.list.count;i++) {
    LOG_I(RRC, "SIB5 InterFreqCarrierFreq element %d/%d\n",i,interFreqCarrierFreqList.list.count);
    ifcfInfo = interFreqCarrierFreqList.list.array[i];
Cedric Roux's avatar
Cedric Roux committed
3689
    LOG_I(RRC, "   DL Carrier Frequency/ARFCN : %ld/%ld\n",
3690 3691
	  arfcn_to_freq(ifcfInfo->dl_CarrierFreq),
	  ifcfInfo->dl_CarrierFreq);
Cedric Roux's avatar
Cedric Roux committed
3692 3693 3694 3695
    LOG_I(RRC,"   Q_RXLevMin : %ld\n", ifcfInfo->q_RxLevMin);
    if (ifcfInfo->p_Max != NULL)
      LOG_I(RRC,"   P_max : %ld\n", *ifcfInfo->p_Max);
    LOG_I(RRC,"   T_ReselectionEUTRA : %ld\n",ifcfInfo->t_ReselectionEUTRA);
3696
    if (ifcfInfo->t_ReselectionEUTRA_SF) {
Cedric Roux's avatar
Cedric Roux committed
3697
      LOG_I(RRC,"   t_ReselectionEUTRA_SF.sf_Medium %ld, t_ReselectionEUTRA_SF.sf_High %ld",
3698 3699 3700
	    ifcfInfo->t_ReselectionEUTRA_SF->sf_Medium,
	    ifcfInfo->t_ReselectionEUTRA_SF->sf_High);
    }
Cedric Roux's avatar
Cedric Roux committed
3701 3702
    LOG_I(RRC,"   threshX_High : %ld\n",ifcfInfo->threshX_High);
    LOG_I(RRC,"   threshX_Low : %ld\n",ifcfInfo->threshX_Low);
3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727
    switch(ifcfInfo->allowedMeasBandwidth) {
    case AllowedMeasBandwidth_mbw6:
      LOG_I(RRC,"   AllowedMeasBandwidth : 6\n");
      break;
    case AllowedMeasBandwidth_mbw15:
      LOG_I(RRC,"   AllowedMeasBandwidth : 15\n");
      break;
    case AllowedMeasBandwidth_mbw25:
      LOG_I(RRC,"   AllowedMeasBandwidth : 25\n");
      break;
    case AllowedMeasBandwidth_mbw50:
      LOG_I(RRC,"   AllowedMeasBandwidth : 50\n");
      break;
    case AllowedMeasBandwidth_mbw75:
      LOG_I(RRC,"   AllowedMeasBandwidth : 75\n");
      break;
    case AllowedMeasBandwidth_mbw100:
      LOG_I(RRC,"   AllowedMeasBandwidth : 100\n");
      break;
    }
    if (ifcfInfo->presenceAntennaPort1)
      LOG_I(RRC,"   PresenceAntennaPort1 : True\n");
    else
      LOG_I(RRC,"   PresenceAntennaPort1 : False\n");
    if (ifcfInfo->cellReselectionPriority) {
Cedric Roux's avatar
Cedric Roux committed
3728
      LOG_I(RRC,"   CellReselectionPriority : %ld\n",
3729 3730 3731
	    *ifcfInfo->cellReselectionPriority);
    }
    LOG_I(RRC,"   NeighCellConfig  : ");
3732 3733
    for (j=0;j<ifcfInfo->neighCellConfig.size;j++) {
      printf("%2x ",ifcfInfo->neighCellConfig.buf[j]);
3734
    }
3735
    printf("\n");
3736
    if (ifcfInfo->q_OffsetFreq)
3737
      LOG_I(RRC,"   Q_OffsetFreq : %d\n",Qoffsettab[*ifcfInfo->q_OffsetFreq]);
3738
    if (ifcfInfo->interFreqNeighCellList) {
3739

3740
      for (j=0;j<ifcfInfo->interFreqNeighCellList->list.count;j++) {
Cedric Roux's avatar
Cedric Roux committed
3741 3742 3743
	LOG_I(RRC,"   Cell %d\n", j);
	LOG_I(RRC,"      PhysCellId : %ld\n",ifcfInfo->interFreqNeighCellList->list.array[j]->physCellId);
	LOG_I(RRC,"      Q_OffsetRange : %ld\n",ifcfInfo->interFreqNeighCellList->list.array[j]->q_OffsetCell);
3744

3745 3746 3747
      }
    }
    if (ifcfInfo->interFreqBlackCellList) {
3748

3749
      for (j=0;j<ifcfInfo->interFreqBlackCellList->list.count;j++) {
Cedric Roux's avatar
Cedric Roux committed
3750 3751
	LOG_I(RRC,"   Cell %d\n", j);
	LOG_I(RRC,"      PhysCellId start: %ld\n",ifcfInfo->interFreqBlackCellList->list.array[j]->start);
3752
	if (ifcfInfo->interFreqBlackCellList->list.array[i]->range) {
Cedric Roux's avatar
Cedric Roux committed
3753
	  LOG_I(RRC,"      PhysCellId Range : %ld\n",*ifcfInfo->interFreqBlackCellList->list.array[j]->range);
3754 3755 3756
	}
      }
    }
Cedric Roux's avatar
Cedric Roux committed
3757
#if defined(Rel10) || defined(Rel14)
3758
    if (ifcfInfo->ext1 && ifcfInfo->ext1->q_QualMin_r9)
Cedric Roux's avatar
Cedric Roux committed
3759
      LOG_I(RRC,"   Q_QualMin_r9 : %ld\n",*ifcfInfo->ext1->q_QualMin_r9);
3760

3761
    if (ifcfInfo->ext1 && ifcfInfo->ext1->threshX_Q_r9) {
Cedric Roux's avatar
Cedric Roux committed
3762 3763
      LOG_I(RRC,"   threshX_HighQ_r9 : %ld\n",ifcfInfo->ext1->threshX_Q_r9->threshX_HighQ_r9);
      LOG_I(RRC,"   threshX_LowQ_r9: %ld\n",ifcfInfo->ext1->threshX_Q_r9->threshX_LowQ_r9);
3764
    }
roux's avatar
roux committed
3765
#endif
3766
  }
3767

3768
}
3769

Cedric Roux's avatar
Cedric Roux committed
3770
#if defined(Rel10) || defined(Rel14)
3771
 void dump_sib13( SystemInformationBlockType13_r9_t *sib13 )
3772
{
3773 3774 3775 3776 3777
  LOG_I( RRC, "[UE] Dumping SIB13\n" );
  LOG_I( RRC, "[UE] dumping sib13 second time\n" );
  LOG_I( RRC, "[UE] NotificationRepetitionCoeff-r9 : %ld\n", sib13->notificationConfig_r9.notificationRepetitionCoeff_r9 );
  LOG_I( RRC, "[UE] NotificationOffset-r9 : %d\n", (int)sib13->notificationConfig_r9.notificationOffset_r9 );
  LOG_I( RRC, "[UE] NotificationSF-Index-r9 : %d\n", (int)sib13->notificationConfig_r9.notificationSF_Index_r9 );
3778 3779
}
#endif
winckel's avatar
winckel committed
3780

3781
//TTN - SIB18
3782
//-----------------------------------------------------------------------------
3783
 void dump_sib18(SystemInformationBlockType18_r12_t *sib18){
3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794
   LOG_I( RRC, "[UE] Dumping SIB18\n" );
   for (int i = 0; i < sib18->commConfig_r12->commRxPool_r12.list.count; i++) {
       LOG_I(RRC, " Contents of SIB18 %d/%d \n", i+1, sib18->commConfig_r12->commRxPool_r12.list.count);
       LOG_I(RRC, " SIB18 rxPool_sc_CP_Len: %d \n", sib18->commConfig_r12->commRxPool_r12.list.array[i]->sc_CP_Len_r12);
       LOG_I(RRC, " SIB18 sc_Period_r12: %d \n", sib18->commConfig_r12->commRxPool_r12.list.array[i]->sc_Period_r12);
       LOG_I(RRC, " SIB18 data_CP_Len_r12: %d \n", sib18->commConfig_r12->commRxPool_r12.list.array[i]->data_CP_Len_r12);
       LOG_I(RRC, " SIB18 prb_Num_r12: %d \n", sib18->commConfig_r12->commRxPool_r12.list.array[i]->sc_TF_ResourceConfig_r12.prb_Num_r12);
       LOG_I(RRC, " SIB18 prb_Start_r12: %d \n", sib18->commConfig_r12->commRxPool_r12.list.array[i]->sc_TF_ResourceConfig_r12.prb_Start_r12);
       LOG_I(RRC, " SIB18 prb_End_r12: %d \n", sib18->commConfig_r12->commRxPool_r12.list.array[i]->sc_TF_ResourceConfig_r12.prb_End_r12);
       //to add more log
     }
3795
}
3796

3797 3798
//TTN -  SIB19
//-----------------------------------------------------------------------------
3799
 void dump_sib19(SystemInformationBlockType19_r12_t *sib19){
3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811
   LOG_I( RRC, "[UE] Dumping SIB19\n" );
   for (int i = 0; i < sib19->discConfig_r12->discRxPool_r12.list.count; i++) {
       LOG_I(RRC, " Contents of SIB18 %d/%d \n", i+1, sib19->discConfig_r12->discRxPool_r12.list.count);
       LOG_I(RRC, " SIB19 cp_Len_r12: %d \n", sib19->discConfig_r12->discRxPool_r12.list.array[i]->cp_Len_r12);
       LOG_I(RRC, " SIB19 discPeriod_r12: %d \n", sib19->discConfig_r12->discRxPool_r12.list.array[i]->discPeriod_r12);
       LOG_I(RRC, " SIB19 numRetx_r12: %d \n", sib19->discConfig_r12->discRxPool_r12.list.array[i]->numRetx_r12);
       LOG_I(RRC, " SIB19 numRepetition_r12: %d \n", sib19->discConfig_r12->discRxPool_r12.list.array[i]->numRepetition_r12);
       LOG_I(RRC, " SIB19 prb_Num_r12: %d \n", sib19->discConfig_r12->discRxPool_r12.list.array[i]->tf_ResourceConfig_r12.prb_Num_r12);
       LOG_I(RRC, " SIB19 prb_Start_r12: %d \n", sib19->discConfig_r12->discRxPool_r12.list.array[i]->tf_ResourceConfig_r12.prb_Start_r12);
       LOG_I(RRC, " SIB19 prb_End_r12: %d \n", sib19->discConfig_r12->discRxPool_r12.list.array[i]->tf_ResourceConfig_r12.prb_End_r12);
       //to add more log
     }
3812
}
3813

3814
//-----------------------------------------------------------------------------
3815
 int decode_SI( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index )
3816
{
3817 3818
	LOG_I( RRC, "Panos-D: decode_SI 1 \n");
	//printf("Panos-D: decode_SI 1 \n");
3819
  SystemInformation_t** si = &UE_rrc_inst[ctxt_pP->module_id].si[eNB_index];
3820 3821
  int new_sib = 0;
  SystemInformationBlockType1_t* sib1 = UE_rrc_inst[ctxt_pP->module_id].sib1[eNB_index];
3822

3823
  LOG_I( RRC, "Panos-D: decode_SI 2 \n");
3824
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_UE_DECODE_SI, VCD_FUNCTION_IN );
3825 3826

  // Dump contents
3827 3828
  //TTN - should be modified since we use SystemInformation__criticalExtensions_PR_criticalExtensionsFuture
  // instead of SystemInformation__criticalExtensions_PR_systemInformation_r8
3829 3830 3831 3832
  // Panos: I brought this if condition back to previous form in order to prevent crashing. Pending to
  // modify for SystemInformation__criticalExtensions_PR_criticalExtensionsFuture
  if ((*si)->criticalExtensions.present == SystemInformation__criticalExtensions_PR_systemInformation_r8) {
  //if ((*si)->criticalExtensions.present == SystemInformation__criticalExtensions_PR_criticalExtensionsFuture) {
3833 3834
    LOG_D( RRC, "[UE] (*si)->criticalExtensions.choice.systemInformation_r8.sib_TypeAndInfo.list.count %d\n",
           (*si)->criticalExtensions.choice.systemInformation_r8.sib_TypeAndInfo.list.count );
3835
  } else {
3836
	  LOG_I( RRC, "Panos-D: decode_SI 2.3 \n");
3837
    LOG_D( RRC, "[UE] Unknown criticalExtension version (not Rel8)\n" );
3838
    return -1;
3839 3840
  }

3841
  LOG_I( RRC, "Panos-D: decode_SI 3 \n");
3842 3843 3844 3845
  for (int i=0; i<(*si)->criticalExtensions.choice.systemInformation_r8.sib_TypeAndInfo.list.count; i++) {
    LOG_D( RRC, "SI count %d\n", i );
    struct SystemInformation_r8_IEs__sib_TypeAndInfo__Member *typeandinfo;
    typeandinfo = (*si)->criticalExtensions.choice.systemInformation_r8.sib_TypeAndInfo.list.array[i];
3846

3847 3848
    switch(typeandinfo->present) {
    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib2:
3849
    	LOG_I( RRC, "Panos-D: decode_SI 4 \n");
3850 3851 3852 3853 3854 3855 3856 3857
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&2) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=2;
	new_sib=1;
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib2[eNB_index], &typeandinfo->choice.sib2, sizeof(SystemInformationBlockType2_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB2 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
	dump_sib2( UE_rrc_inst[ctxt_pP->module_id].sib2[eNB_index] );
	LOG_I( RRC, "[FRAME %05"PRIu32"][RRC_UE][MOD %02"PRIu8"][][--- MAC_CONFIG_REQ (SIB2 params  eNB %"PRIu8") --->][MAC_UE][MOD %02"PRIu8"][]\n",
	       ctxt_pP->frame, ctxt_pP->module_id, eNB_index, ctxt_pP->module_id );
3858

3859 3860 3861
	rrc_mac_config_req_ue(ctxt_pP->module_id, 0, eNB_index,
			      &UE_rrc_inst[ctxt_pP->module_id].sib2[eNB_index]->radioResourceConfigCommon,
			      (struct PhysicalConfigDedicated *)NULL,
Cedric Roux's avatar
Cedric Roux committed
3862
#if defined(Rel10) || defined(Rel14)
3863
			      (SCellToAddMod_r10_t *)NULL,
3864
#endif
3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877
			      (MeasObjectToAddMod_t **)NULL,
			      (MAC_MainConfig_t *)NULL,
			      0,
			      (struct LogicalChannelConfig *)NULL,
			      (MeasGapConfig_t *)NULL,
			      (TDD_Config_t *)NULL,
			      (MobilityControlInfo_t *)NULL,
			      NULL,
			      NULL,
			      UE_rrc_inst[ctxt_pP->module_id].sib2[eNB_index]->freqInfo.ul_CarrierFreq,
			      UE_rrc_inst[ctxt_pP->module_id].sib2[eNB_index]->freqInfo.ul_Bandwidth,
			      &UE_rrc_inst[ctxt_pP->module_id].sib2[eNB_index]->freqInfo.additionalSpectrumEmission,
			      UE_rrc_inst[ctxt_pP->module_id].sib2[eNB_index]->mbsfn_SubframeConfigList
Cedric Roux's avatar
Cedric Roux committed
3878
#if defined(Rel10) || defined(Rel14)
3879 3880 3881
			      ,0,
			      (MBSFN_AreaInfoList_r9_t *)NULL,
			      (PMCH_InfoList_r9_t *)NULL
3882

3883 3884
#endif
#ifdef CBA
3885 3886
			      ,0,
			      0
3887 3888 3889
#endif
#if defined(Rel14)
           ,
3890
           0,
3891
           NULL,
3892
           NULL
3893
#endif
3894
			      );
3895
	// After SI is received, prepare RRCConnectionRequest
Cedric Roux's avatar
Cedric Roux committed
3896
#if defined(Rel10) || defined(Rel14)
3897

3898
	if (UE_rrc_inst[ctxt_pP->module_id].MBMS_flag < 3) // see -Q option
3899
#endif
winckel's avatar
winckel committed
3900
#if !(defined(ENABLE_ITTI) && defined(ENABLE_USE_MME))
3901
	  rrc_ue_generate_RRCConnectionRequest( ctxt_pP, eNB_index );
3902

winckel's avatar
winckel committed
3903
#endif
3904

3905 3906 3907
	if (UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].State == RRC_IDLE) {
	  LOG_I( RRC, "[UE %d] Received SIB1/SIB2/SIB3 Switching to RRC_SI_RECEIVED\n", ctxt_pP->module_id );
	  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].State = RRC_SI_RECEIVED;
3908
#if ENABLE_RAL
3909 3910 3911
	  {
	    MessageDef                            *message_ral_p = NULL;
	    rrc_ral_system_information_ind_t       ral_si_ind;
3912

3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929
	    message_ral_p = itti_alloc_new_message (TASK_RRC_UE, RRC_RAL_SYSTEM_INFORMATION_IND);
	    memset(&ral_si_ind, 0, sizeof(rrc_ral_system_information_ind_t));
	    ral_si_ind.plmn_id.MCCdigit2 = '0';
	    ral_si_ind.plmn_id.MCCdigit1 = '2';
	    ral_si_ind.plmn_id.MNCdigit3 = '0';
	    ral_si_ind.plmn_id.MCCdigit3 = '8';
	    ral_si_ind.plmn_id.MNCdigit2 = '9';
	    ral_si_ind.plmn_id.MNCdigit1 = '9';
	    ral_si_ind.cell_id        = 1;
	    ral_si_ind.dbm            = 0;
	    //ral_si_ind.dbm            = fifo_dump_emos_UE.PHY_measurements->rx_rssi_dBm[eNB_index];
	    // TO DO
	    ral_si_ind.sinr           = 0;
	    //ral_si_ind.sinr           = fifo_dump_emos_UE.PHY_measurements->subband_cqi_dB[eNB_index][phy_vars_ue->lte_frame_parms.nb_antennas_rx][0];
	    // TO DO
	    ral_si_ind.link_data_rate = 0;
	    memcpy (&message_ral_p->ittiMsg, (void *) &ral_si_ind, sizeof(rrc_ral_system_information_ind_t));
Lionel Gauthier's avatar
 
Lionel Gauthier committed
3930
#warning "ue_mod_idP ? for instance ?"
3931 3932
	    itti_send_msg_to_task (TASK_RAL_UE, UE_MODULE_ID_TO_INSTANCE(ctxt_pP->module_id), message_ral_p);
	  }
3933
#endif
3934
	}
3935
      }
3936
      break; // case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib2
3937 3938

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib3:
3939
    	LOG_I( RRC, "Panos-D: decode_SI 5 \n");
3940 3941 3942 3943 3944 3945 3946 3947
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&4) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=4;
	new_sib=1;
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib3[eNB_index], &typeandinfo->choice.sib3, sizeof(SystemInformationBlockType3_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB3 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
	dump_sib3( UE_rrc_inst[ctxt_pP->module_id].sib3[eNB_index] );

      }
3948 3949 3950
      break;

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib4:
3951 3952 3953 3954 3955 3956 3957
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&8) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=8;
	new_sib=1;
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib4[eNB_index], &typeandinfo->choice.sib4, sizeof(SystemInformationBlockType4_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB4 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
      }

3958 3959 3960
      break;

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib5:
3961 3962 3963
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&16) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=16;
	new_sib=1;
3964

3965 3966
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib5[eNB_index], &typeandinfo->choice.sib5, sizeof(SystemInformationBlockType5_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB5 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
3967
	dump_sib5(UE_rrc_inst[ctxt_pP->module_id].sib5[eNB_index]);
3968
      }
3969 3970 3971
      break;

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib6:
3972 3973 3974
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&32) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=32;
	new_sib=1;
3975

3976 3977 3978
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib6[eNB_index], &typeandinfo->choice.sib6, sizeof(SystemInformationBlockType6_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB6 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
      }
3979 3980 3981
      break;

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib7:
3982 3983 3984 3985 3986 3987
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&64) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=64;
	new_sib=1;
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib7[eNB_index], &typeandinfo->choice.sib7, sizeof(SystemInformationBlockType7_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB7 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
      }
3988 3989 3990
      break;

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib8:
3991 3992 3993 3994 3995 3996
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&128) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=128;
	new_sib=1;
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib8[eNB_index], &typeandinfo->choice.sib8, sizeof(SystemInformationBlockType8_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB8 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
      }
3997 3998 3999
      break;

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib9:
4000 4001 4002
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&256) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=256;
	new_sib=1;
4003

4004 4005 4006
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib9[eNB_index], &typeandinfo->choice.sib9, sizeof(SystemInformationBlockType9_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB9 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
      }
4007 4008 4009
      break;

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib10:
4010 4011 4012 4013 4014 4015
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&512) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=512;
	new_sib=1;
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib10[eNB_index], &typeandinfo->choice.sib10, sizeof(SystemInformationBlockType10_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB10 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
      }
4016 4017 4018
      break;

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib11:
4019 4020 4021 4022 4023 4024 4025
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1024) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=1024;
	new_sib=1;

	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib11[eNB_index], &typeandinfo->choice.sib11, sizeof(SystemInformationBlockType11_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB11 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
      }
4026
      break;
4027

Cedric Roux's avatar
Cedric Roux committed
4028
#if defined(Rel10) || defined(Rel14)
4029 4030

    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib12_v920:
4031 4032 4033 4034 4035 4036
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&2048) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=2048;
	new_sib=1;
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib12[eNB_index], &typeandinfo->choice.sib12_v920, sizeof(SystemInformationBlockType12_r9_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB12 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
      }
4037
      break;
4038

4039
    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib13_v920:
4040 4041 4042
      if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&4096) == 0) {
	UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=4096;
	new_sib=1;
4043

4044 4045 4046 4047
	memcpy( UE_rrc_inst[ctxt_pP->module_id].sib13[eNB_index], &typeandinfo->choice.sib13_v920, sizeof(SystemInformationBlockType13_r9_t) );
	LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB13 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
	dump_sib13( UE_rrc_inst[ctxt_pP->module_id].sib13[eNB_index] );
	// adding here function to store necessary parameters for using in decode_MCCH_Message + maybe transfer to PHY layer
4048
	LOG_I( RRC, "[FRAME %05"PRIu32"][RRC_UE][MOD %02"PRIu8"][][--- MAC_CONFIG_REQ (SIB13 params eNB %"PRIu8") --->][MAC_UE][MOD %02"PRIu8"][]\n",
4049
	       ctxt_pP->frame, ctxt_pP->module_id, eNB_index, ctxt_pP->module_id);
4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069
	rrc_mac_config_req_ue(ctxt_pP->module_id,0,eNB_index,
			      (RadioResourceConfigCommonSIB_t *)NULL,
			      (struct PhysicalConfigDedicated *)NULL,
			      (SCellToAddMod_r10_t *)NULL,
			      (MeasObjectToAddMod_t **)NULL,
			      (MAC_MainConfig_t *)NULL,
			      0,
			      (struct LogicalChannelConfig *)NULL,
			      (MeasGapConfig_t *)NULL,
			      (TDD_Config_t *)NULL,
			      (MobilityControlInfo_t *)NULL,
			      NULL,
			      NULL,
			      NULL,
			      NULL,
			      NULL,
			      (MBSFN_SubframeConfigList_t *)NULL,
			      0,
			      &UE_rrc_inst[ctxt_pP->module_id].sib13[eNB_index]->mbsfn_AreaInfoList_r9,
			      (PMCH_InfoList_r9_t *)NULL
4070
#ifdef CBA
4071 4072
			      ,0,
			      0
4073 4074 4075
#endif
#if defined(Rel14)
           ,
4076
           0,
4077
           NULL,
4078
           NULL
4079
#endif
4080
			      );
4081 4082
	break;
      }
4083
#endif
4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095
    //TTN - SIB18
    case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib18_v1250:
       if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&8192) == 0) {
          UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=8192;
          new_sib=1;

          memcpy( UE_rrc_inst[ctxt_pP->module_id].sib18[eNB_index], &typeandinfo->choice.sib18_v1250, sizeof(SystemInformationBlockType18_r12_t) );
          LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB18 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
          dump_sib18( UE_rrc_inst[ctxt_pP->module_id].sib18[eNB_index] );
          // adding here function to store necessary parameters to transfer to PHY layer
          LOG_I( RRC, "[FRAME %05"PRIu32"][RRC_UE][MOD %02"PRIu8"][][--- MAC_CONFIG_REQ (SIB18 params eNB %"PRIu8") --->][MAC_UE][MOD %02"PRIu8"][]\n",
                    ctxt_pP->frame, ctxt_pP->module_id, eNB_index, ctxt_pP->module_id);
4096 4097

          //process SIB18 to transfer SL-related parameters to PHY
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
4098
          rrc_ue_process_sidelink_radioResourceConfig(ctxt_pP->module_id,eNB_index,
4099 4100 4101 4102 4103
                UE_rrc_inst[ctxt_pP->module_id].sib18[eNB_index],
                (SystemInformationBlockType19_r12_t *)NULL,
                (SL_CommConfig_r12_t *)NULL,
                (SL_DiscConfig_r12_t *)NULL
                );
4104 4105 4106 4107

       }
       break;

4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119
       //TTN - SIB19
       case SystemInformation_r8_IEs__sib_TypeAndInfo__Member_PR_sib19_v1250:
          if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&16384) == 0) {
             UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus|=16384;
             new_sib=1;

             memcpy( UE_rrc_inst[ctxt_pP->module_id].sib19[eNB_index], &typeandinfo->choice.sib19_v1250, sizeof(SystemInformationBlockType19_r12_t) );
             LOG_I( RRC, "[UE %"PRIu8"] Frame %"PRIu32" Found SIB19 from eNB %"PRIu8"\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_index );
             dump_sib19( UE_rrc_inst[ctxt_pP->module_id].sib19[eNB_index] );
             // adding here function to store necessary parameters to transfer to PHY layer
             LOG_I( RRC, "[FRAME %05"PRIu32"][RRC_UE][MOD %02"PRIu8"][][--- MAC_CONFIG_REQ (SIB19 params eNB %"PRIu8") --->][MAC_UE][MOD %02"PRIu8"][]\n",
                       ctxt_pP->frame, ctxt_pP->module_id, eNB_index, ctxt_pP->module_id);
4120
             //process SIB19 to transfer SL-related parameters to PHY
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
4121
             rrc_ue_process_sidelink_radioResourceConfig(ctxt_pP->module_id,eNB_index,
4122 4123 4124 4125 4126
                   (SystemInformationBlockType18_r12_t *)NULL,
                   UE_rrc_inst[ctxt_pP->module_id].sib19[eNB_index],
                   (SL_CommConfig_r12_t *)NULL,
                   (SL_DiscConfig_r12_t *)NULL
                   );
4127 4128 4129 4130

          }
          break;

4131 4132 4133
    default:
      break;
    }
4134 4135

  }
4136 4137 4138 4139 4140 4141
  if (new_sib == 1) {
    UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIcnt++;

    if (UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIcnt == sib1->schedulingInfoList.list.count)
      rrc_set_sub_state( ctxt_pP->module_id, RRC_SUB_STATE_IDLE_SIB_COMPLETE );

4142
    LOG_I(RRC,"SIStatus %x, SIcnt %d/%d\n",
4143 4144 4145 4146
	  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus,
	  UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIcnt,
	  sib1->schedulingInfoList.list.count);
  }
4147

4148
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_UE_DECODE_SI  , VCD_FUNCTION_OUT);
4149 4150 4151
  return 0;
}

4152
// layer 3 filtering of RSRP (EUTRA) measurements: 36.331, Sec. 5.5.3.2
4153
//-----------------------------------------------------------------------------
4154
void ue_meas_filtering( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index )
4155
{
4156 4157
  float a  = UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrp; // 'a' in 36.331 Sec. 5.5.3.2
  float a1 = UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrq;
4158
  //float rsrp_db, rsrq_db;
4159
  uint8_t    eNB_offset;
4160

4161 4162 4163
  if(UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[0] != NULL) { // Only consider 1 serving cell (index: 0)
    if (UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[0]->quantityConfigEUTRA != NULL) {
      if(UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[0]->quantityConfigEUTRA->filterCoefficientRSRP != NULL) {
4164 4165 4166 4167 4168 4169 4170
        for (eNB_offset = 0; eNB_offset<1+get_n_adj_cells(ctxt_pP->module_id,0); eNB_offset++) {
          UE_rrc_inst[ctxt_pP->module_id].rsrp_db[eNB_offset] = get_RSRP(ctxt_pP->module_id,0,eNB_offset);
	  /*
	  (dB_fixed_times10(get_RSRP(ctxt_pP->module_id,0,eNB_offset))/10.0) -
	  get_rx_total_gain_dB(ctxt_pP->module_id,0) -
	  get_bw_gain_dB(ctxt_pP->module_id);
	  */
4171 4172 4173
          UE_rrc_inst[ctxt_pP->module_id].rsrp_db_filtered[eNB_offset] =
            (1.0-a)*UE_rrc_inst[ctxt_pP->module_id].rsrp_db_filtered[eNB_offset] +
            a*UE_rrc_inst[ctxt_pP->module_id].rsrp_db[eNB_offset];
4174

4175 4176 4177
          LOG_D(RRC,"RSRP_dBm: %3.2f \n",get_RSRP(ctxt_pP->module_id,0,eNB_offset));;
	  /*          LOG_D(RRC,"gain_loss_dB: %d \n",get_rx_total_gain_dB(ctxt_pP->module_id,0));
		      LOG_D(RRC,"gain_fixed_dB: %d \n",dB_fixed(frame_parms->N_RB_DL*12));*/
4178
          LOG_D(PHY,"[UE %d] Frame %d, RRC Measurements => rssi %3.1f dBm (digital: %3.1f dB)\n",
4179 4180
                ctxt_pP->module_id,
                ctxt_pP->frame,
4181 4182
                10*log10(get_RSSI(ctxt_pP->module_id,0))-get_rx_total_gain_dB(ctxt_pP->module_id,0),
                10*log10(get_RSSI(ctxt_pP->module_id,0)));
Cedric Roux's avatar
Cedric Roux committed
4183
          LOG_D(RRC,"[UE %d] Frame %d: Meas RSRP: eNB_offset: %d rsrp_coef: %3.1f filter_coef: %ld before L3 filtering: rsrp: %3.1f after L3 filtering: rsrp: %3.1f \n ",
4184 4185
                ctxt_pP->module_id,
                ctxt_pP->frame, eNB_offset,a,
4186
                *UE_rrc_inst->QuantityConfig[0]->quantityConfigEUTRA->filterCoefficientRSRP,
4187 4188
                UE_rrc_inst[ctxt_pP->module_id].rsrp_db[eNB_offset],
                UE_rrc_inst[ctxt_pP->module_id].rsrp_db_filtered[eNB_offset]);
4189
        }
4190
      }
4191
    } else {
4192 4193
      for (eNB_offset = 0; eNB_offset<1+get_n_adj_cells(ctxt_pP->module_id,0); eNB_offset++) {
        UE_rrc_inst[ctxt_pP->module_id].rsrp_db_filtered[eNB_offset]= get_RSRP(ctxt_pP->module_id,0,eNB_offset);
4194
      }
4195 4196
    }

4197 4198
    if (UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[0]->quantityConfigEUTRA != NULL) {
      if(UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[0]->quantityConfigEUTRA->filterCoefficientRSRQ != NULL) {
4199 4200
        for (eNB_offset = 0; eNB_offset<1+get_n_adj_cells(ctxt_pP->module_id,0); eNB_offset++) {
          UE_rrc_inst[ctxt_pP->module_id].rsrq_db[eNB_offset] = (10*log10(get_RSRQ(ctxt_pP->module_id,0,eNB_offset)))-20;
4201 4202
          UE_rrc_inst[ctxt_pP->module_id].rsrq_db_filtered[eNB_offset]=(1-a1)*UE_rrc_inst[ctxt_pP->module_id].rsrq_db_filtered[eNB_offset] +
              a1 *UE_rrc_inst[ctxt_pP->module_id].rsrq_db[eNB_offset];
4203
        }
4204
      }
4205
    } else {
4206 4207
      for (eNB_offset = 0; eNB_offset<1+get_n_adj_cells(ctxt_pP->module_id,0); eNB_offset++) {
        UE_rrc_inst[ctxt_pP->module_id].rsrq_db_filtered[eNB_offset]= get_RSRQ(ctxt_pP->module_id,0,eNB_offset);
4208
      }
4209
    }
4210 4211 4212
  }
}

4213
//Below routine implements Measurement Reporting procedure from 36.331 Section 5.5.5
4214
//-----------------------------------------------------------------------------
4215
 void rrc_ue_generate_MeasurementReport(protocol_ctxt_t* const ctxt_pP, uint8_t eNB_index )
4216
{
4217 4218 4219 4220 4221 4222

  uint8_t             buffer[32], size;
  uint8_t             i;
  uint8_t             target_eNB_offset;
  MeasId_t         measId;
  PhysCellId_t     cellId, targetCellId;
4223 4224 4225
  long             rsrp_t,rsrq_t;
  long             rsrp_s,rsrq_s;
  long             nElem, nElem1;
4226 4227 4228
  float            rsrp_filtered, rsrq_filtered;
  static frame_t   pframe=0;
  int              result;
4229 4230 4231

  nElem = 98;
  nElem1 = 35;
4232
  target_eNB_offset = UE_rrc_inst[ctxt_pP->module_id].Info[0].handoverTarget; // eNB_offset of target eNB: used to obtain the mod_id of target eNB
4233

4234
  for (i=0; i<MAX_MEAS_ID; i++) {
4235 4236
    if (UE_rrc_inst[ctxt_pP->module_id].measReportList[0][i] != NULL) {
      measId = UE_rrc_inst[ctxt_pP->module_id].measReportList[0][i]->measId;
4237 4238

      // Note: Values in the meas report have to be the mapped values...to implement binary search for LUT
4239
      rsrp_filtered = UE_rrc_inst[ctxt_pP->module_id].rsrp_db_filtered[eNB_index];//nid_cell];
4240 4241
      rsrp_s = binary_search_float(RSRP_meas_mapping,nElem, rsrp_filtered);

4242
      rsrq_filtered = UE_rrc_inst[ctxt_pP->module_id].rsrq_db_filtered[eNB_index];//nid_cell]; //RSRQ of serving cell
4243 4244 4245
      rsrq_s = binary_search_float(RSRQ_meas_mapping,nElem1,rsrq_filtered);//mapped RSRQ of serving cell

      LOG_D(RRC,"[UE %d] Frame %d: source eNB %d :rsrp_s: %ld rsrq_s: %ld rsrp_filtered: %f rsrq_filtered: %f \n",
4246 4247 4248 4249 4250 4251 4252 4253 4254
            ctxt_pP->module_id,
            ctxt_pP->frame,
            eNB_index,
            rsrp_s,
            rsrq_s,
            rsrp_filtered,
            rsrq_filtered);
      rsrp_t = binary_search_float(RSRP_meas_mapping,nElem,UE_rrc_inst[ctxt_pP->module_id].rsrp_db_filtered[target_eNB_offset]); //RSRP of target cell
      rsrq_t = binary_search_float(RSRQ_meas_mapping,nElem1,UE_rrc_inst[ctxt_pP->module_id].rsrq_db_filtered[target_eNB_offset]); //RSRQ of target cell
4255 4256

      LOG_D(RRC,"[UE %d] Frame %d: target eNB %d :rsrp_t: %ld rsrq_t: %ld rsrp_filtered: %f rsrq_filtered: %f \n",
4257 4258 4259 4260 4261 4262 4263
            ctxt_pP->module_id,
            ctxt_pP->frame,
            target_eNB_offset,
            rsrp_t,
            rsrq_t,
            UE_rrc_inst[ctxt_pP->module_id].rsrp_db_filtered[target_eNB_offset],
            UE_rrc_inst[ctxt_pP->module_id].rsrq_db_filtered[target_eNB_offset]);
4264 4265

      //  if (measFlag == 1) {
4266 4267
      cellId = get_adjacent_cell_id(ctxt_pP->module_id, eNB_index); //PhycellId of serving cell
      targetCellId = UE_rrc_inst[ctxt_pP->module_id].HandoverInfoUe.targetCellId ;//get_adjacent_cell_id(ue_mod_idP,target_eNB_offset); //PhycellId of target cell
4268

4269 4270
      if (pframe!=ctxt_pP->frame) {
        pframe=ctxt_pP->frame;
Cedric Roux's avatar
Cedric Roux committed
4271
        LOG_D(RRC, "[UE %d] Frame %d: doing MeasReport: servingCell(%ld) targetCell(%ld) rsrp_s(%ld) rsrq_s(%ld) rsrp_t(%ld) rsrq_t(%ld) \n",
4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282
              ctxt_pP->module_id,
              ctxt_pP->frame,
              cellId,
              targetCellId,
              rsrp_s,
              rsrq_s,
              rsrp_t,
              rsrq_t);
        size = do_MeasurementReport(ctxt_pP->module_id, buffer,measId,targetCellId,rsrp_s,rsrq_s,rsrp_t,rsrq_t);
        LOG_I(RRC, "[UE %d] Frame %d : Generating Measurement Report for eNB %d\n",
              ctxt_pP->module_id, ctxt_pP->frame, eNB_index);
4283 4284 4285 4286 4287
        result = pdcp_data_req(ctxt_pP,  SRB_FLAG_YES, DCCH, rrc_mui++, 0, size, buffer, PDCP_TRANSMISSION_MODE_DATA
#ifdef Rel14
                               ,NULL, NULL
#endif
                               );
4288 4289
        AssertFatal (result == TRUE, "PDCP data request failed!\n");
        //LOG_D(RRC, "[UE %d] Frame %d Sending MeasReport (%d bytes) through DCCH%d to PDCP \n",ue_mod_idP,frameP, size, DCCH);
4290
      }
4291 4292 4293 4294

      //          measFlag = 0; //re-setting measFlag so that no more MeasReports are sent in this frameP
      //          }
    }
4295 4296 4297
  }
}

4298
// Measurement report triggering, described in 36.331 Section 5.5.4.1: called periodically
4299
//-----------------------------------------------------------------------------
4300
void ue_measurement_report_triggering(protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index )
4301
{
4302
  uint8_t               i,j;
4303 4304 4305 4306 4307 4308 4309 4310
  Hysteresis_t     hys;
  TimeToTrigger_t  ttt_ms;
  Q_OffsetRange_t  ofn;
  Q_OffsetRange_t  ocn;
  Q_OffsetRange_t  ofs = 0;
  Q_OffsetRange_t  ocs = 0;
  long             a3_offset;
  MeasObjectId_t   measObjId;
4311
  ReportConfigId_t reportConfigId;
4312

4313
  for(i=0 ; i<NB_CNX_UE ; i++) {
4314
    for(j=0 ; j<MAX_MEAS_ID ; j++) {
4315 4316 4317
      if(UE_rrc_inst[ctxt_pP->module_id].MeasId[i][j] != NULL) {
        measObjId = UE_rrc_inst[ctxt_pP->module_id].MeasId[i][j]->measObjectId;
        reportConfigId = UE_rrc_inst[ctxt_pP->module_id].MeasId[i][j]->reportConfigId;
4318

4319 4320
        if( /*UE_rrc_inst[ctxt_pP->module_id].MeasId[i][j] != NULL && */ UE_rrc_inst[ctxt_pP->module_id].MeasObj[i][measObjId-1] != NULL) {
          if(UE_rrc_inst[ctxt_pP->module_id].MeasObj[i][measObjId-1]->measObject.present == MeasObjectToAddMod__measObject_PR_measObjectEUTRA) {
4321 4322 4323
            /* consider any neighboring cell detected on the associated frequency to be
             * applicable when the concerned cell is not included in the blackCellsToAddModList
             * defined within the VarMeasConfig for this measId */
4324 4325 4326 4327 4328 4329 4330 4331 4332
            //    LOG_I(RRC,"event %d %d %p \n", measObjId,reportConfigId, UE_rrc_inst[ctxt_pP->module_id].ReportConfig[i][reportConfigId-1]);
            if((UE_rrc_inst[ctxt_pP->module_id].ReportConfig[i][reportConfigId-1] != NULL) &&
                (UE_rrc_inst[ctxt_pP->module_id].ReportConfig[i][reportConfigId-1]->reportConfig.present==ReportConfigToAddMod__reportConfig_PR_reportConfigEUTRA) &&
                (UE_rrc_inst[ctxt_pP->module_id].ReportConfig[i][reportConfigId-1]->reportConfig.choice.reportConfigEUTRA.triggerType.present ==
                 ReportConfigEUTRA__triggerType_PR_event)) {
              hys = UE_rrc_inst[ctxt_pP->module_id].ReportConfig[i][reportConfigId-1]->reportConfig.choice.reportConfigEUTRA.triggerType.choice.event.hysteresis;
              //LOG_N(RRC,"[UE%d] Frame %d Check below lines for segfault :), Fix me \n",ctxt_pP->module_id, frameP);
              ttt_ms = timeToTrigger_ms[UE_rrc_inst[ctxt_pP->module_id].ReportConfig[i][reportConfigId
                                        -1]->reportConfig.choice.reportConfigEUTRA.triggerType.choice.event.timeToTrigger];
4333
              // Freq specific offset of neighbor cell freq
4334 4335
              ofn = 5;//((UE_rrc_inst[ctxt_pP->module_id].MeasObj[i][measObjId-1]->measObject.choice.measObjectEUTRA.offsetFreq != NULL) ?
              // *UE_rrc_inst[ctxt_pP->module_id].MeasObj[i][measObjId-1]->measObject.choice.measObjectEUTRA.offsetFreq : 15); //  /* 15 is the Default */
4336 4337
              // cellIndividualOffset of neighbor cell - not defined yet
              ocn = 0;
4338 4339
              a3_offset = UE_rrc_inst[ctxt_pP->module_id].ReportConfig[i][reportConfigId
                          -1]->reportConfig.choice.reportConfigEUTRA.triggerType.choice.event.eventId.choice.eventA3.a3_Offset;
4340

4341
              switch (UE_rrc_inst[ctxt_pP->module_id].ReportConfig[i][reportConfigId-1]->reportConfig.choice.reportConfigEUTRA.triggerType.choice.event.eventId.present) {
4342
              case ReportConfigEUTRA__triggerType__event__eventId_PR_eventA1:
4343 4344
                LOG_D(RRC,"[UE %d] Frame %d : A1 event: check if serving becomes better than threshold\n",
                      ctxt_pP->module_id, ctxt_pP->frame);
4345 4346 4347
                break;

              case ReportConfigEUTRA__triggerType__event__eventId_PR_eventA2:
4348 4349
                LOG_D(RRC,"[UE %d] Frame %d : A2 event, check if serving becomes worse than a threshold\n",
                      ctxt_pP->module_id, ctxt_pP->frame);
4350 4351 4352
                break;

              case ReportConfigEUTRA__triggerType__event__eventId_PR_eventA3:
4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363
                LOG_D(RRC,"[UE %d] Frame %d : A3 event: check if a neighboring cell becomes offset better than serving to trigger a measurement event \n",
                      ctxt_pP->module_id, ctxt_pP->frame);

                if ((check_trigger_meas_event(
                       ctxt_pP->module_id,
                       ctxt_pP->frame,
                       eNB_index,
                       i,j,ofn,ocn,hys,ofs,ocs,a3_offset,ttt_ms)) &&
                    (UE_rrc_inst[ctxt_pP->module_id].Info[0].State >= RRC_CONNECTED) &&
                    (UE_rrc_inst[ctxt_pP->module_id].Info[0].T304_active == 0 )      &&
                    (UE_rrc_inst[ctxt_pP->module_id].HandoverInfoUe.measFlag == 1)) {
4364
                  //trigger measurement reporting procedure (36.331, section 5.5.5)
4365 4366
                  if (UE_rrc_inst[ctxt_pP->module_id].measReportList[i][j] == NULL) {
                    UE_rrc_inst[ctxt_pP->module_id].measReportList[i][j] = malloc(sizeof(MEAS_REPORT_LIST));
4367 4368
                  }

4369 4370 4371 4372 4373 4374 4375 4376
                  UE_rrc_inst[ctxt_pP->module_id].measReportList[i][j]->measId = UE_rrc_inst[ctxt_pP->module_id].MeasId[i][j]->measId;
                  UE_rrc_inst[ctxt_pP->module_id].measReportList[i][j]->numberOfReportsSent = 0;
                  rrc_ue_generate_MeasurementReport(
                    ctxt_pP,
                    eNB_index);
                  UE_rrc_inst[ctxt_pP->module_id].HandoverInfoUe.measFlag = 1;
                  LOG_I(RRC,"[UE %d] Frame %d: A3 event detected, state: %d \n",
                        ctxt_pP->module_id, ctxt_pP->frame, UE_rrc_inst[ctxt_pP->module_id].Info[0].State);
4377
                } else {
4378 4379
                  if(UE_rrc_inst[ctxt_pP->module_id].measReportList[i][j] != NULL) {
                    free(UE_rrc_inst[ctxt_pP->module_id].measReportList[i][j]);
4380
                  }
4381

4382
                  UE_rrc_inst[ctxt_pP->module_id].measReportList[i][j] = NULL;
4383 4384 4385 4386 4387
                }

                break;

              case ReportConfigEUTRA__triggerType__event__eventId_PR_eventA4:
4388 4389
                LOG_D(RRC,"[UE %d] Frame %d : received an A4 event, neighbor becomes offset better than a threshold\n",
                      ctxt_pP->module_id, ctxt_pP->frame);
4390 4391 4392
                break;

              case ReportConfigEUTRA__triggerType__event__eventId_PR_eventA5:
4393 4394
                LOG_D(RRC,"[UE %d] Frame %d: received an A5 event, serving becomes worse than threshold 1 and neighbor becomes better than threshold 2\n",
                      ctxt_pP->module_id, ctxt_pP->frame);
4395 4396 4397 4398
                break;

              default:
                LOG_D(RRC,"Invalid ReportConfigEUTRA__triggerType__event__eventId: %d",
4399
                      UE_rrc_inst[ctxt_pP->module_id].ReportConfig[i][j]->reportConfig.choice.reportConfigEUTRA.triggerType.present);
4400
                break;
winckel's avatar
winckel committed
4401
              }
4402
            }
winckel's avatar
winckel committed
4403
          }
4404
        }
4405
      }
4406
    }
4407 4408 4409
  }
}

Lionel Gauthier's avatar
 
Lionel Gauthier committed
4410
//check_trigger_meas_event(ue_mod_idP, frameP, eNB_index, i,j,ofn,ocn,hys,ofs,ocs,a3_offset,ttt_ms)
4411
//-----------------------------------------------------------------------------
4412

4413
 uint8_t check_trigger_meas_event(
4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424
  module_id_t     ue_mod_idP,
  frame_t         frameP,
  uint8_t         eNB_index,
  uint8_t         ue_cnx_index,
  uint8_t         meas_index,
  Q_OffsetRange_t ofn,
  Q_OffsetRange_t ocn,
  Hysteresis_t    hys,
  Q_OffsetRange_t ofs,
  Q_OffsetRange_t ocs,
  long            a3_offset,
4425
  TimeToTrigger_t ttt )
Lionel Gauthier's avatar
Lionel Gauthier committed
4426
{
4427
  uint8_t eNB_offset;
4428
  //  uint8_t currentCellIndex = frame_parms->Nid_cell;
4429
  uint8_t tmp_offset;
Lionel Gauthier's avatar
Lionel Gauthier committed
4430

Cedric Roux's avatar
Cedric Roux committed
4431
  LOG_I(RRC,"[UE %d] ofn(%ld) ocn(%ld) hys(%ld) ofs(%ld) ocs(%ld) a3_offset(%ld) ttt(%ld) rssi %3.1f\n",
4432 4433
        ue_mod_idP,
        ofn,ocn,hys,ofs,ocs,a3_offset,ttt,
4434
        10*log10(get_RSSI(ue_mod_idP,0))-get_rx_total_gain_dB(ue_mod_idP,0));
4435

4436
  for (eNB_offset = 0; eNB_offset<1+get_n_adj_cells(ue_mod_idP,0); eNB_offset++) {
4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447
    /* RHS: Verify that idx 0 corresponds to currentCellIndex in rsrp array */
    if((eNB_offset!=eNB_index)&&(eNB_offset<NB_eNB_INST)) {
      if(eNB_offset<eNB_index) {
        tmp_offset = eNB_offset;
      } else {
        tmp_offset = eNB_offset-1;
      }

      if(UE_rrc_inst[ue_mod_idP].rsrp_db_filtered[eNB_offset]+ofn+ocn-hys > UE_rrc_inst[ue_mod_idP].rsrp_db_filtered[eNB_index]+ofs+ocs-1/*+a3_offset*/) {
        UE_rrc_inst->measTimer[ue_cnx_index][meas_index][tmp_offset] += 2; //Called every subframe = 2ms
        LOG_D(RRC,"[UE %d] Frame %d: Entry measTimer[%d][%d][%d]: %d currentCell: %d betterCell: %d \n",
4448
              ue_mod_idP, frameP, ue_cnx_index,meas_index,tmp_offset,UE_rrc_inst->measTimer[ue_cnx_index][meas_index][tmp_offset],0,eNB_offset);
4449 4450 4451
      } else {
        UE_rrc_inst->measTimer[ue_cnx_index][meas_index][tmp_offset] = 0; //Exit condition: Resetting the measurement timer
        LOG_D(RRC,"[UE %d] Frame %d: Exit measTimer[%d][%d][%d]: %d currentCell: %d betterCell: %d \n",
4452
              ue_mod_idP, frameP, ue_cnx_index,meas_index,tmp_offset,UE_rrc_inst->measTimer[ue_cnx_index][meas_index][tmp_offset],0,eNB_offset);
4453 4454 4455 4456
      }

      if (UE_rrc_inst->measTimer[ue_cnx_index][meas_index][tmp_offset] >= ttt) {
        UE_rrc_inst->HandoverInfoUe.targetCellId = get_adjacent_cell_id(ue_mod_idP,tmp_offset); //WARNING!!!...check this!
4457
        LOG_D(RRC,"[UE %d] Frame %d eNB %d: Handover triggered: targetCellId: %ld currentCellId: %d eNB_offset: %d rsrp source: %3.1f rsrp target: %3.1f\n",
4458 4459
              ue_mod_idP, frameP, eNB_index,
              UE_rrc_inst->HandoverInfoUe.targetCellId,ue_cnx_index,eNB_offset,
4460 4461
	      get_RSRP(ue_mod_idP,0,0),
	      get_RSRP(ue_mod_idP,0,1));
4462 4463 4464 4465 4466 4467 4468 4469 4470
        UE_rrc_inst->Info[0].handoverTarget = eNB_offset;
        //LOG_D(RRC,"PHY_ID: %d \n",UE_rrc_inst->HandoverInfoUe.targetCellId);
        return 1;
      }

      // else{
      //  LOG_D(RRC,"Condition does not hold\n");
      // }
    }
4471
  }
4472

4473 4474 4475
  return 0;
}

Cedric Roux's avatar
Cedric Roux committed
4476
#if defined(Rel10) || defined(Rel14)
4477
//-----------------------------------------------------------------------------
4478
int decode_MCCH_Message( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index, const uint8_t* const Sdu, const uint8_t Sdu_len, const uint8_t mbsfn_sync_area )
Lionel Gauthier's avatar
Lionel Gauthier committed
4479
{
4480

Lionel Gauthier's avatar
Lionel Gauthier committed
4481
  MCCH_Message_t               *mcch=NULL;
4482
  MBSFNAreaConfiguration_r9_t** mcch_message=&UE_rrc_inst[ctxt_pP->module_id].mcch_message[eNB_index];
4483

Lionel Gauthier's avatar
Lionel Gauthier committed
4484
  asn_dec_rval_t                dec_rval;
4485

4486
  if (UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].MCCHStatus[mbsfn_sync_area] == 1) {
4487
    LOG_D(RRC,"[UE %d] Frame %d: MCCH MESSAGE for MBSFN sync area %d has been already received!\n",
4488 4489 4490
          ctxt_pP->module_id,
          ctxt_pP->frame,
          mbsfn_sync_area);
4491 4492 4493 4494 4495 4496 4497 4498 4499
    return 0; // avoid decoding to prevent memory bloating
  } else {
    dec_rval = uper_decode_complete(NULL,
                                    &asn_DEF_MCCH_Message,
                                    (void **)&mcch,
                                    (const void *)Sdu,
                                    Sdu_len);

    if ((dec_rval.code != RC_OK) && (dec_rval.consumed==0)) {
Cedric Roux's avatar
Cedric Roux committed
4500
      LOG_E(RRC,"[UE %d] Failed to decode MCCH__MESSAGE (%lu bits)\n",
4501 4502
            ctxt_pP->module_id,
            dec_rval.consumed);
4503 4504 4505 4506 4507
      //free the memory
      SEQUENCE_free(&asn_DEF_MCCH_Message, (void*)mcch, 1);
      return -1;
    }

4508
#ifdef XER_PRINT
4509
    xer_fprint(stdout, &asn_DEF_MCCH_Message, (void*)mcch);
4510 4511
#endif

4512
    if (mcch->message.present == MCCH_MessageType_PR_c1) {
4513 4514
      LOG_D(RRC,"[UE %d] Found mcch message \n",
            ctxt_pP->module_id);
4515 4516 4517

      if(mcch->message.choice.c1.present == MCCH_MessageType__c1_PR_mbsfnAreaConfiguration_r9) {
        /*
winckel's avatar
winckel committed
4518
        memcpy((void*)*mcch_message,
4519 4520 4521
         (void*)&mcch->message.choice.c1.choice.mbsfnAreaConfiguration_r9,
         sizeof(MBSFNAreaConfiguration_r9_t)); */
        *mcch_message = &mcch->message.choice.c1.choice.mbsfnAreaConfiguration_r9;
4522 4523 4524 4525 4526 4527 4528 4529 4530
        LOG_I(RRC,"[UE %d] Frame %d : Found MBSFNAreaConfiguration from eNB %d \n",
              ctxt_pP->module_id,
              ctxt_pP->frame,
              eNB_index);
        decode_MBSFNAreaConfiguration(
          ctxt_pP->module_id,
          eNB_index,
          ctxt_pP->frame,
          mbsfn_sync_area);
4531 4532

      }
4533
    }
4534
  }
4535

4536 4537 4538
  return 0;
}

4539
//-----------------------------------------------------------------------------
4540
 void decode_MBSFNAreaConfiguration( module_id_t ue_mod_idP, uint8_t eNB_index, frame_t frameP, uint8_t mbsfn_sync_area )
Lionel Gauthier's avatar
Lionel Gauthier committed
4541
{
4542
  protocol_ctxt_t               ctxt;
Lionel Gauthier's avatar
Lionel Gauthier committed
4543

4544
  LOG_I(RRC,"[UE %d] Frame %d : Number of MCH(s) in the MBSFN Sync Area %d  is %d\n",
4545
        ue_mod_idP, frameP, mbsfn_sync_area, UE_rrc_inst[ue_mod_idP].mcch_message[eNB_index]->pmch_InfoList_r9.list.count);
4546
  //  store to MAC/PHY necessary parameters for receiving MTCHs
4547

4548 4549 4550
  rrc_mac_config_req_ue(ue_mod_idP,0,eNB_index,
			(RadioResourceConfigCommonSIB_t *)NULL,
			(struct PhysicalConfigDedicated *)NULL,
Cedric Roux's avatar
Cedric Roux committed
4551
#if defined(Rel10) || defined(Rel14)
4552 4553
			(SCellToAddMod_r10_t *)NULL,
			//(struct PhysicalConfigDedicatedSCell_r10 *)NULL,
4554
#endif
4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567
			(MeasObjectToAddMod_t **)NULL,
			(MAC_MainConfig_t *)NULL,
			0,
			(struct LogicalChannelConfig *)NULL,
			(MeasGapConfig_t *)NULL,
			(TDD_Config_t *)NULL,
			(MobilityControlInfo_t *)NULL,
			NULL,
			NULL,
			NULL,
			NULL,
			NULL,
			(MBSFN_SubframeConfigList_t *)NULL
Cedric Roux's avatar
Cedric Roux committed
4568
#if defined(Rel10) || defined(Rel14)
4569 4570 4571 4572
			,
			0,
			(MBSFN_AreaInfoList_r9_t *)NULL,
			&UE_rrc_inst[ue_mod_idP].mcch_message[eNB_index]->pmch_InfoList_r9
4573

4574 4575
#endif
#ifdef CBA
4576 4577 4578
			,
			0,
			0
4579 4580 4581
#endif
#if defined(Rel14)
           ,
4582
           0,
4583
           NULL,
4584
           NULL
4585
#endif
4586
			);
4587

Lionel Gauthier's avatar
 
Lionel Gauthier committed
4588
  UE_rrc_inst[ue_mod_idP].Info[eNB_index].MCCHStatus[mbsfn_sync_area] = 1;
4589

4590
  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_idP, ENB_FLAG_NO, UE_rrc_inst[ue_mod_idP].Info[eNB_index].rnti, frameP, 0,eNB_index);
Lionel Gauthier's avatar
Lionel Gauthier committed
4591

4592
  // Config Radio Bearer for MBMS user data (similar way to configure for eNB side in init_MBMS function)
Lionel Gauthier's avatar
Lionel Gauthier committed
4593
  rrc_pdcp_config_asn1_req(&ctxt,
4594 4595 4596 4597 4598 4599 4600
                           NULL, // SRB_ToAddModList
                           NULL, // DRB_ToAddModList
                           (DRB_ToReleaseList_t*)NULL,
                           0, // security mode
                           NULL, // key rrc encryption
                           NULL, // key rrc integrity
                           NULL // key encryption
Cedric Roux's avatar
Cedric Roux committed
4601
#if defined(Rel10) || defined(Rel14)
4602
                           ,&(UE_rrc_inst[ue_mod_idP].mcch_message[eNB_index]->pmch_InfoList_r9)
4603
#endif
4604
                           ,NULL);
winckel's avatar
winckel committed
4605

Lionel Gauthier's avatar
Lionel Gauthier committed
4606
  rrc_rlc_config_asn1_req(&ctxt,
4607 4608 4609
                          NULL,// SRB_ToAddModList
                          NULL,// DRB_ToAddModList
                          NULL,// DRB_ToReleaseList
Cedric Roux's avatar
Cedric Roux committed
4610
#if defined(Rel10) || defined(Rel14)
4611
                          &(UE_rrc_inst[ue_mod_idP].mcch_message[eNB_index]->pmch_InfoList_r9)
4612
                          , 0, 0
4613 4614
#endif
                         );
4615
  // */
4616

4617 4618 4619 4620 4621 4622 4623
}

#endif // rel10

#ifndef USER_MODE
EXPORT_SYMBOL(Rlc_info_am_config);
#endif
4624 4625

#if defined(ENABLE_ITTI)
4626
//-----------------------------------------------------------------------------
4627
void *rrc_ue_task( void *args_p )
Lionel Gauthier's avatar
Lionel Gauthier committed
4628
{
4629 4630 4631
  MessageDef   *msg_p;
  const char   *msg_name;
  instance_t    instance;
Lionel Gauthier's avatar
 
Lionel Gauthier committed
4632
  unsigned int  ue_mod_id;
4633 4634
  int           result;
  SRB_INFO     *srb_info_p;
4635

4636
  protocol_ctxt_t  ctxt;
4637 4638 4639
  itti_mark_task_ready (TASK_RRC_UE);

  while(1) {
4640 4641
    // Wait for a message
    itti_receive_msg (TASK_RRC_UE, &msg_p);
4642

4643 4644
    msg_name = ITTI_MSG_NAME (msg_p);
    instance = ITTI_MSG_INSTANCE (msg_p);
4645
    ue_mod_id = UE_INSTANCE_TO_MODULE_ID(instance);
4646

4647 4648 4649 4650
    switch (ITTI_MSG_ID(msg_p)) {
    case TERMINATE_MESSAGE:
      itti_exit_task ();
      break;
4651

4652
    case MESSAGE_TEST:
4653
      LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, msg_name);
4654
      break;
4655

4656 4657 4658
      /* MAC messages */
    case RRC_MAC_IN_SYNC_IND:
      LOG_D(RRC, "[UE %d] Received %s: frameP %d, eNB %d\n", ue_mod_id, msg_name,
4659
            RRC_MAC_IN_SYNC_IND (msg_p).frame, RRC_MAC_IN_SYNC_IND (msg_p).enb_index);
4660

4661
      UE_rrc_inst[ue_mod_id].Info[RRC_MAC_IN_SYNC_IND (msg_p).enb_index].N310_cnt = 0;
4662

4663
      if (UE_rrc_inst[ue_mod_id].Info[RRC_MAC_IN_SYNC_IND (msg_p).enb_index].T310_active == 1) {
4664
        UE_rrc_inst[ue_mod_id].Info[RRC_MAC_IN_SYNC_IND (msg_p).enb_index].N311_cnt++;
4665
      }
4666 4667 4668 4669

      break;

    case RRC_MAC_OUT_OF_SYNC_IND:
4670
      LOG_D(RRC, "[UE %d] Received %s: frameP %d, eNB %d\n", ue_mod_id, msg_name,
4671
            RRC_MAC_OUT_OF_SYNC_IND (msg_p).frame, RRC_MAC_OUT_OF_SYNC_IND (msg_p).enb_index);
4672

4673 4674
      UE_rrc_inst[ue_mod_id].Info[RRC_MAC_OUT_OF_SYNC_IND (msg_p).enb_index].N310_cnt ++;
      break;
4675

4676 4677
    case RRC_MAC_BCCH_DATA_IND:
      LOG_D(RRC, "[UE %d] Received %s: frameP %d, eNB %d\n", ue_mod_id, msg_name,
4678
            RRC_MAC_BCCH_DATA_IND (msg_p).frame, RRC_MAC_BCCH_DATA_IND (msg_p).enb_index);
4679

4680 4681
      //      PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, ENB_FLAG_NO, NOT_A_RNTI, RRC_MAC_BCCH_DATA_IND (msg_p).frame, 0);
      PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, NOT_A_RNTI, RRC_MAC_BCCH_DATA_IND (msg_p).frame, 0,RRC_MAC_BCCH_DATA_IND (msg_p).enb_index);
4682 4683 4684
      decode_BCCH_DLSCH_Message (&ctxt,
                                 RRC_MAC_BCCH_DATA_IND (msg_p).enb_index,
                                 RRC_MAC_BCCH_DATA_IND (msg_p).sdu,
4685
                                 RRC_MAC_BCCH_DATA_IND (msg_p).sdu_size,
4686 4687
                                 RRC_MAC_BCCH_DATA_IND (msg_p).rsrq,
                                 RRC_MAC_BCCH_DATA_IND (msg_p).rsrp);
4688
      break;
4689

4690
    case RRC_MAC_CCCH_DATA_CNF:
4691
      LOG_D(RRC, "[UE %d] Received %s: eNB %d\n", ue_mod_id, msg_name,
4692
            RRC_MAC_CCCH_DATA_CNF (msg_p).enb_index);
4693

4694 4695 4696
      // reset the tx buffer to indicate RRC that ccch was successfully transmitted (for example if contention resolution succeeds)
      UE_rrc_inst[ue_mod_id].Srb0[RRC_MAC_CCCH_DATA_CNF (msg_p).enb_index].Tx_buffer.payload_size = 0;
      break;
4697

4698
    case RRC_MAC_CCCH_DATA_IND:
4699
      LOG_D(RRC, "[UE %d] RNTI %x Received %s: frameP %d, eNB %d\n",
4700 4701 4702 4703 4704
            ue_mod_id,
            RRC_MAC_CCCH_DATA_IND (msg_p).rnti,
            msg_name,
            RRC_MAC_CCCH_DATA_IND (msg_p).frame,
            RRC_MAC_CCCH_DATA_IND (msg_p).enb_index);
4705

4706
      srb_info_p = &UE_rrc_inst[ue_mod_id].Srb0[RRC_MAC_CCCH_DATA_IND (msg_p).enb_index];
4707

4708 4709 4710
      memcpy (srb_info_p->Rx_buffer.Payload, RRC_MAC_CCCH_DATA_IND (msg_p).sdu,
              RRC_MAC_CCCH_DATA_IND (msg_p).sdu_size);
      srb_info_p->Rx_buffer.payload_size = RRC_MAC_CCCH_DATA_IND (msg_p).sdu_size;
4711 4712
      //      PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, ENB_FLAG_NO, RRC_MAC_CCCH_DATA_IND (msg_p).rnti, RRC_MAC_CCCH_DATA_IND (msg_p).frame, 0);
      PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, RRC_MAC_CCCH_DATA_IND (msg_p).rnti, RRC_MAC_CCCH_DATA_IND (msg_p).frame, 0, RRC_MAC_CCCH_DATA_IND (msg_p).enb_index);
4713 4714
      rrc_ue_decode_ccch (&ctxt,
                          srb_info_p,
4715 4716
                          RRC_MAC_CCCH_DATA_IND (msg_p).enb_index);
      break;
4717

Cedric Roux's avatar
Cedric Roux committed
4718
# if defined(Rel10) || defined(Rel14)
4719 4720

    case RRC_MAC_MCCH_DATA_IND:
4721
      LOG_D(RRC, "[UE %d] Received %s: frameP %d, eNB %d, mbsfn SA %d\n", ue_mod_id, msg_name,
4722
            RRC_MAC_MCCH_DATA_IND (msg_p).frame, RRC_MAC_MCCH_DATA_IND (msg_p).enb_index, RRC_MAC_MCCH_DATA_IND (msg_p).mbsfn_sync_area);
4723

4724 4725
      //PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, ENB_FLAG_NO, M_RNTI, RRC_MAC_MCCH_DATA_IND (msg_p).frame, 0);
      PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, M_RNTI, RRC_MAC_MCCH_DATA_IND (msg_p).frame, 0,RRC_MAC_MCCH_DATA_IND (msg_p).enb_index);
4726 4727 4728 4729 4730
      decode_MCCH_Message (
        &ctxt,
        RRC_MAC_MCCH_DATA_IND (msg_p).enb_index,
        RRC_MAC_MCCH_DATA_IND (msg_p).sdu,
        RRC_MAC_MCCH_DATA_IND (msg_p).sdu_size,
4731
        RRC_MAC_MCCH_DATA_IND (msg_p).mbsfn_sync_area);
4732
      break;
4733 4734 4735 4736 4737 4738 4739 4740 4741

  /*  //TTN (for D2D)
    case RRC_MAC_SL_DISCOVERY_DATA_IND:
       LOG_D(RRC, "[UE %d] Received %s: frameP %d, eNB %d\n", ue_mod_id, msg_name,
             RRC_MAC_SL_DISCOVERY_DATA_IND (msg_p).frame, RRC_MAC_SL_DISCOVERY_DATA_IND (msg_p).enb_index);
       PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, M_RNTI, RRC_MAC_SL_DISCOVERY_DATA_IND (msg_p).frame, 0,RRC_MAC_SL_DISCOVERY_DATA_IND (msg_p).enb_index);
       //send to ProSeApp
       break;
*/
4742
# endif
4743

4744 4745
      /* PDCP messages */
    case RRC_DCCH_DATA_IND:
4746
      PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, RRC_DCCH_DATA_IND (msg_p).module_id, ENB_FLAG_NO, RRC_DCCH_DATA_IND (msg_p).rnti, RRC_DCCH_DATA_IND (msg_p).frame, 0,RRC_DCCH_DATA_IND (msg_p).eNB_index);
4747
      LOG_D(RRC, "[UE %d] Received %s: frameP %d, DCCH %d, eNB %d\n",
4748 4749 4750 4751
            RRC_DCCH_DATA_IND (msg_p).module_id,
            msg_name,
            RRC_DCCH_DATA_IND (msg_p).frame,
            RRC_DCCH_DATA_IND (msg_p).dcch_index,
4752
            RRC_DCCH_DATA_IND (msg_p).eNB_index);
4753

4754
      LOG_D(RRC, PROTOCOL_RRC_CTXT_UE_FMT"Received %s DCCH %d, eNB %d\n",
4755 4756 4757 4758 4759 4760 4761 4762 4763
            PROTOCOL_RRC_CTXT_UE_ARGS(&ctxt),
            msg_name,
            RRC_DCCH_DATA_IND (msg_p).dcch_index,
            RRC_DCCH_DATA_IND (msg_p).eNB_index);
      rrc_ue_decode_dcch (
        &ctxt,
        RRC_DCCH_DATA_IND (msg_p).dcch_index,
        RRC_DCCH_DATA_IND (msg_p).sdu_p,
        RRC_DCCH_DATA_IND (msg_p).eNB_index);
4764 4765 4766 4767
      // Message buffer has been processed, free it now.
      result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), RRC_DCCH_DATA_IND (msg_p).sdu_p);
      AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
      break;
4768

4769 4770
# if defined(ENABLE_USE_MME)

4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794
    case NAS_KENB_REFRESH_REQ:
        memcpy((void*)UE_rrc_inst[ue_mod_id].kenb, (void*)NAS_KENB_REFRESH_REQ(msg_p).kenb, sizeof(UE_rrc_inst[ue_mod_id].kenb));

        LOG_D(RRC, "[UE %d] Received %s: refreshed RRC::KeNB = "
            "%02x%02x%02x%02x"
            "%02x%02x%02x%02x"
            "%02x%02x%02x%02x"
            "%02x%02x%02x%02x"
            "%02x%02x%02x%02x"
            "%02x%02x%02x%02x"
            "%02x%02x%02x%02x"
            "%02x%02x%02x%02x\n",
            ue_mod_id, msg_name,
            UE_rrc_inst[ue_mod_id].kenb[0],  UE_rrc_inst[ue_mod_id].kenb[1],  UE_rrc_inst[ue_mod_id].kenb[2],  UE_rrc_inst[ue_mod_id].kenb[3],
            UE_rrc_inst[ue_mod_id].kenb[4],  UE_rrc_inst[ue_mod_id].kenb[5],  UE_rrc_inst[ue_mod_id].kenb[6],  UE_rrc_inst[ue_mod_id].kenb[7],
            UE_rrc_inst[ue_mod_id].kenb[8],  UE_rrc_inst[ue_mod_id].kenb[9],  UE_rrc_inst[ue_mod_id].kenb[10], UE_rrc_inst[ue_mod_id].kenb[11],
            UE_rrc_inst[ue_mod_id].kenb[12], UE_rrc_inst[ue_mod_id].kenb[13], UE_rrc_inst[ue_mod_id].kenb[14], UE_rrc_inst[ue_mod_id].kenb[15],
            UE_rrc_inst[ue_mod_id].kenb[16], UE_rrc_inst[ue_mod_id].kenb[17], UE_rrc_inst[ue_mod_id].kenb[18], UE_rrc_inst[ue_mod_id].kenb[19],
            UE_rrc_inst[ue_mod_id].kenb[20], UE_rrc_inst[ue_mod_id].kenb[21], UE_rrc_inst[ue_mod_id].kenb[22], UE_rrc_inst[ue_mod_id].kenb[23],
            UE_rrc_inst[ue_mod_id].kenb[24], UE_rrc_inst[ue_mod_id].kenb[25], UE_rrc_inst[ue_mod_id].kenb[26], UE_rrc_inst[ue_mod_id].kenb[27],
            UE_rrc_inst[ue_mod_id].kenb[28], UE_rrc_inst[ue_mod_id].kenb[29], UE_rrc_inst[ue_mod_id].kenb[30], UE_rrc_inst[ue_mod_id].kenb[31]);

      break;

4795 4796 4797
      /* NAS messages */
    case NAS_CELL_SELECTION_REQ:

Cedric Roux's avatar
Cedric Roux committed
4798 4799 4800 4801 4802 4803 4804 4805
      LOG_D(RRC, "[UE %d] Received %s: state %d, plmnID (%d%d%d.%d%d%d), rat %x\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id),
            NAS_CELL_SELECTION_REQ (msg_p).plmnID.MCCdigit1,
            NAS_CELL_SELECTION_REQ (msg_p).plmnID.MCCdigit2,
            NAS_CELL_SELECTION_REQ (msg_p).plmnID.MCCdigit3,
            NAS_CELL_SELECTION_REQ (msg_p).plmnID.MNCdigit1,
            NAS_CELL_SELECTION_REQ (msg_p).plmnID.MNCdigit2,
            NAS_CELL_SELECTION_REQ (msg_p).plmnID.MNCdigit3,
            NAS_CELL_SELECTION_REQ (msg_p).rat);
4806

4807 4808 4809 4810
      if (rrc_get_state(ue_mod_id) == RRC_STATE_INACTIVE) {
        // have a look at MAC/main.c void dl_phy_sync_success(...)
        openair_rrc_ue_init(ue_mod_id,0);
      }
4811

4812 4813 4814 4815
      /* Save cell selection criterion */
      {
        UE_rrc_inst[ue_mod_id].plmnID = NAS_CELL_SELECTION_REQ (msg_p).plmnID;
        UE_rrc_inst[ue_mod_id].rat = NAS_CELL_SELECTION_REQ (msg_p).rat;
4816
        LOG_D(RRC, "[UE %d] Save cell selection criterion MCC %X%X%X MNC %X%X%X\n",
4817 4818 4819 4820 4821 4822 4823
              ue_mod_id,
              UE_rrc_inst[ue_mod_id].plmnID.MCCdigit1,
              UE_rrc_inst[ue_mod_id].plmnID.MCCdigit2,
              UE_rrc_inst[ue_mod_id].plmnID.MCCdigit3,
              UE_rrc_inst[ue_mod_id].plmnID.MNCdigit1,
              UE_rrc_inst[ue_mod_id].plmnID.MNCdigit2,
              UE_rrc_inst[ue_mod_id].plmnID.MNCdigit3);
Lionel Gauthier's avatar
Lionel Gauthier committed
4824

4825
      }
4826

4827 4828 4829 4830
      switch (rrc_get_state(ue_mod_id)) {
      case RRC_STATE_INACTIVE: {
        /* Need to first activate lower layers */
        MessageDef *message_p;
4831

4832
        message_p = itti_alloc_new_message(TASK_RRC_UE, ACTIVATE_MESSAGE);
4833

4834
        itti_send_msg_to_task(TASK_L2L1, UE_MODULE_ID_TO_INSTANCE(ue_mod_id), message_p);
4835

4836 4837 4838
        rrc_set_state (ue_mod_id, RRC_STATE_IDLE);
        /* Fall through to next case */
      }
winckel's avatar
winckel committed
4839

4840 4841 4842
      case RRC_STATE_IDLE: {
        /* Ask to layer 1 to find a cell matching the criterion */
        MessageDef *message_p;
winckel's avatar
winckel committed
4843

4844
        message_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_CELL_REQ);
winckel's avatar
winckel committed
4845

4846 4847
        PHY_FIND_CELL_REQ (message_p).earfcn_start = 1;
        PHY_FIND_CELL_REQ (message_p).earfcn_end = 1;
winckel's avatar
winckel committed
4848

4849
        itti_send_msg_to_task(TASK_PHY_UE, UE_MODULE_ID_TO_INSTANCE(ue_mod_id), message_p);
4850
        rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_SEARCHING);
winckel's avatar
winckel committed
4851

4852 4853
        break;
      }
4854

4855 4856 4857 4858
      case RRC_STATE_CONNECTED:
        /* should not happen */
        LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id));
        break;
4859

4860 4861
      default:
        LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
4862
        break;
4863
      }
winckel's avatar
winckel committed
4864

4865
      break;
winckel's avatar
winckel committed
4866

4867
    case NAS_CONN_ESTABLI_REQ:
Cedric Roux's avatar
Cedric Roux committed
4868 4869 4870 4871 4872 4873 4874 4875 4876 4877
      LOG_D(RRC, "[UE %d] Received %s: cause %d, type %d, s_tmsi (mme code %"PRIu8", m-tmsi %"PRIu32"), plmnID (%d%d%d.%d%d%d)\n", ue_mod_id, msg_name, NAS_CONN_ESTABLI_REQ (msg_p).cause,
            NAS_CONN_ESTABLI_REQ (msg_p).type,
            NAS_CONN_ESTABLI_REQ (msg_p).s_tmsi.MMEcode,
            NAS_CONN_ESTABLI_REQ (msg_p).s_tmsi.m_tmsi,
            NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit1,
            NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit2,
            NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit3,
            NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit1,
            NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit2,
            NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit3);
winckel's avatar
winckel committed
4878

4879 4880 4881
      //PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, ENB_FLAG_NO, NOT_A_RNTI, 0, 0);
      PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, NOT_A_RNTI, 0, 0, 0);

4882
      UE_rrc_inst[ue_mod_id].initialNasMsg = NAS_CONN_ESTABLI_REQ (msg_p).initialNasMsg;
winckel's avatar
winckel committed
4883

4884 4885 4886
      switch (rrc_get_state(ue_mod_id)) {
      case RRC_STATE_IDLE: {
        if (rrc_get_sub_state(ue_mod_id) == RRC_SUB_STATE_IDLE_SIB_COMPLETE) {
4887
          rrc_ue_generate_RRCConnectionRequest(&ctxt, 0);
4888
          LOG_D(RRC, "not sending connection request\n");
winckel's avatar
winckel committed
4889

4890 4891
          rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_CONNECTING);
        }
winckel's avatar
winckel committed
4892

4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905
        break;
      }

      case RRC_STATE_INACTIVE:
      case RRC_STATE_CONNECTED:
        /* should not happen */
        LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id));
        break;

      default:
        LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
        break;
      }
winckel's avatar
winckel committed
4906

4907
      break;
winckel's avatar
RRC:  
winckel committed
4908

4909 4910 4911
    case NAS_UPLINK_DATA_REQ: {
      uint32_t length;
      uint8_t *buffer;
winckel's avatar
RRC:  
winckel committed
4912

4913
      LOG_D(RRC, "[UE %d] Received %s: UEid %d\n", ue_mod_id, msg_name, NAS_UPLINK_DATA_REQ (msg_p).UEid);
4914 4915 4916 4917 4918

      /* Create message for PDCP (ULInformationTransfer_t) */
      length = do_ULInformationTransfer(&buffer, NAS_UPLINK_DATA_REQ (msg_p).nasMsg.length, NAS_UPLINK_DATA_REQ (msg_p).nasMsg.data);

      /* Transfer data to PDCP */
4919
      PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, UE_rrc_inst[ue_mod_id].Info[0].rnti, 0, 0,0);
4920

4921
      // check if SRB2 is created, if yes request data_req on DCCH1 (SRB2)
4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939
      if(UE_rrc_inst[ue_mod_id].SRB2_config[0] == NULL)
      {
          rrc_data_req (&ctxt,
                  DCCH,
                  rrc_mui++,
                  SDU_CONFIRM_NO,
                  length, buffer,
                  PDCP_TRANSMISSION_MODE_CONTROL);
      }
      else
      {
          rrc_data_req (&ctxt,
                  DCCH1,
                  rrc_mui++,
                  SDU_CONFIRM_NO,
                  length, buffer,
                  PDCP_TRANSMISSION_MODE_CONTROL);
      }
4940 4941
      break;
    }
4942

4943
# endif
winckel's avatar
RRC:  
winckel committed
4944

4945
# if ENABLE_RAL
4946

4947
    case RRC_RAL_SCAN_REQ:
4948
      LOG_D(RRC, "[UE %d] Received %s: state %d\n", ue_mod_id, msg_name);
4949

4950 4951 4952 4953
      switch (rrc_get_state(ue_mod_id)) {
      case RRC_STATE_INACTIVE: {
        /* Need to first activate lower layers */
        MessageDef *message_p;
4954

4955
        message_p = itti_alloc_new_message(TASK_RRC_UE, ACTIVATE_MESSAGE);
4956

4957
        itti_send_msg_to_task(TASK_L2L1, instance, message_p);
4958

4959 4960 4961
        rrc_set_state (ue_mod_id, RRC_STATE_IDLE);
        /* Fall through to next case */
      }
4962

4963 4964 4965 4966
      case RRC_STATE_IDLE: {
        if (rrc_get_sub_state(ue_mod_id) != RRC_SUB_STATE_IDLE_SEARCHING) {
          /* Ask to layer 1 to find a cell matching the criterion */
          MessageDef *message_p;
4967

4968
          message_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_CELL_REQ);
4969

4970
          rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_SEARCHING);
4971

4972 4973 4974
          PHY_FIND_CELL_REQ (message_p).transaction_id = RRC_RAL_SCAN_REQ (msg_p).transaction_id;
          PHY_FIND_CELL_REQ (message_p).earfcn_start   = 1;
          PHY_FIND_CELL_REQ (message_p).earfcn_end     = 1; //44
4975

4976 4977
          itti_send_msg_to_task(TASK_PHY_UE, instance, message_p);
        }
4978

4979 4980
        break;
      }
4981

4982 4983 4984 4985
      case RRC_STATE_CONNECTED:
        /* should not happen */
        LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id));
        break;
4986

4987 4988 4989 4990
      default:
        LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
        break;
      }
4991

4992
      break;
4993

4994
    case PHY_FIND_CELL_IND:
4995
      LOG_D(RRC, "[UE %d] Received %s: state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id));
4996

4997 4998 4999 5000 5001 5002
      switch (rrc_get_state(ue_mod_id)) {
      case RRC_STATE_IDLE:
        switch (rrc_get_sub_state(ue_mod_id)) {
        case RRC_SUB_STATE_IDLE_SEARCHING: {
          MessageDef *message_p;
          int         i;
5003

5004
          message_p = itti_alloc_new_message(TASK_RRC_UE, RRC_RAL_SCAN_CONF);
5005

5006 5007
          RRC_RAL_SCAN_CONF (message_p).transaction_id = PHY_FIND_CELL_IND(msg_p).transaction_id;
          RRC_RAL_SCAN_CONF (message_p).num_scan_resp  = PHY_FIND_CELL_IND(msg_p).cell_nb;
5008

5009 5010 5011 5012 5013
          for (i = 0 ; i < PHY_FIND_CELL_IND(msg_p).cell_nb; i++) {
            // TO DO
            memset(&RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].link_addr,  0, sizeof(ral_link_addr_t));
            // TO DO
            memset(&RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].network_id, 0, sizeof(ral_network_id_t));
5014

5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042
            RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].sig_strength.choice     = RAL_SIG_STRENGTH_CHOICE_DBM;
            RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].sig_strength._union.dbm = PHY_FIND_CELL_IND(msg_p).cells[i].rsrp;
          }

          rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE);

          itti_send_msg_to_task(TASK_RAL_UE, instance, message_p);
          break;
        }

        default:
          LOG_C(RRC, "[UE %d] Invalid RRC state %d substate %d\n",
                ue_mod_id,
                rrc_get_state(ue_mod_id),
                rrc_get_sub_state(ue_mod_id));
        }

        break;

      case RRC_STATE_INACTIVE:
      case RRC_STATE_CONNECTED:
        /* should not happen */
        LOG_E(RRC, "[UE %d] indication %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id));
        break;

      default:
        LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
        break;
5043
      }
5044

5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058
      break; // PHY_FIND_CELL_IND

    case PHY_MEAS_REPORT_IND: {
      MessageDef *message_p;
      message_p = itti_alloc_new_message(TASK_RRC_UE, RRC_RAL_MEASUREMENT_REPORT_IND);

      memcpy(&RRC_RAL_MEASUREMENT_REPORT_IND (message_p).threshold,
             &PHY_MEAS_REPORT_IND(msg_p).threshold,
             sizeof(RRC_RAL_MEASUREMENT_REPORT_IND (message_p).threshold));

      memcpy(&RRC_RAL_MEASUREMENT_REPORT_IND (message_p).link_param,
             &PHY_MEAS_REPORT_IND(msg_p).link_param,
             sizeof(RRC_RAL_MEASUREMENT_REPORT_IND (message_p).link_param));

5059
      LOG_D(RRC, "[UE %d] PHY_MEAS_REPORT_IN: sending msg %s to %s \n", ue_mod_id, "RRC_RAL_MEASUREMENT_REPORT_IND", "TASK_RAL_UE");
5060 5061 5062 5063 5064 5065 5066 5067 5068
      itti_send_msg_to_task(TASK_RAL_UE, instance, message_p);
      break;
    }

    case RRC_RAL_CONFIGURE_THRESHOLD_REQ:
      rrc_ue_ral_handle_configure_threshold_request(ue_mod_id, msg_p);
      break;

    case RRC_RAL_CONNECTION_ESTABLISHMENT_REQ:
5069
      LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, msg_name);
5070 5071 5072 5073

      switch (rrc_get_state(ue_mod_id)) {
      case RRC_STATE_IDLE: {
        if (rrc_get_sub_state(ue_mod_id) == RRC_SUB_STATE_IDLE_SIB_COMPLETE) {
5074
          PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, UE_rrc_inst[ue_mod_id].Info[0].rnti, 0, 0, 0);
5075
          rrc_ue_generate_RRCConnectionRequest(&ctxt, 0);
5076
          LOG_D(RRC, "not sending connection request\n");
5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096
          rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_CONNECTING);
        }

        break;
      }

      case RRC_STATE_INACTIVE:
      case RRC_STATE_CONNECTED:
        /* should not happen */
        LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id));
        break;

      default:
        LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
        break;
      }

      break;

    case RRC_RAL_CONNECTION_RELEASE_REQ:
5097
      LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, msg_name);
5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109
      break;
#endif

    default:
      LOG_E(RRC, "[UE %d] Received unexpected message %s\n", ue_mod_id, msg_name);
      break;
    }

    result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p);
    AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
    AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
    msg_p = NULL;
5110 5111 5112
  }
}
#endif
5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149



/*------------------------------------------------------------------------------*/
void
openair_rrc_top_init_ue(
			int eMBMS_active,
			char* uecap_xer,
			uint8_t cba_group_active,
			uint8_t HO_active
)
//-----------------------------------------------------------------------------
{

  module_id_t         module_id;
  OAI_UECapability_t *UECap     = NULL;
  int                 CC_id;

  /* for no gcc warnings */
  (void)CC_id;

  LOG_D(RRC, "[OPENAIR][INIT] Init function start: NB_UE_INST=%d, NB_eNB_INST=%d\n", NB_UE_INST, NB_eNB_INST);

  if (NB_UE_INST > 0) {
    UE_rrc_inst = (UE_RRC_INST*) malloc16(NB_UE_INST*sizeof(UE_RRC_INST));
    memset (UE_rrc_inst, 0, NB_UE_INST * sizeof(UE_RRC_INST));
    LOG_D(RRC, "ALLOCATE %d Bytes for UE_RRC_INST @ %p\n", (unsigned int)(NB_UE_INST*sizeof(UE_RRC_INST)), UE_rrc_inst);

    // fill UE capability
    UECap = fill_ue_capability (uecap_xer);

    for (module_id = 0; module_id < NB_UE_INST; module_id++) {
      UE_rrc_inst[module_id].UECap = UECap;
      UE_rrc_inst[module_id].UECapability = UECap->sdu;
      UE_rrc_inst[module_id].UECapability_size = UECap->sdu_size;
    }

5150
#if defined(Rel10) || defined(Rel14)
5151 5152 5153 5154 5155 5156 5157
    LOG_I(RRC,"[UE] eMBMS active state is %d \n", eMBMS_active);

    for (module_id=0; module_id<NB_UE_INST; module_id++) {
      UE_rrc_inst[module_id].MBMS_flag = (uint8_t)eMBMS_active;
    }

#endif
5158 5159 5160 5161 5162

#ifdef Rel14
  init_SL_preconfig(&UE_rrc_inst[module_id],0);
#endif

5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177
  } else {
    UE_rrc_inst = NULL;
  }

}

//-----------------------------------------------------------------------------
void
rrc_top_cleanup_ue(
  void
)
//-----------------------------------------------------------------------------
{

  if (NB_UE_INST > 0) free (UE_rrc_inst);
5178

5179 5180

}
5181 5182 5183


//-----------------------------------------------------------------------------
5184
uint8_t rrc_ue_generate_SidelinkUEInformation( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index,SL_DestinationInfoList_r12_t  *destinationInfoList, long *discTxResourceReq, SL_TRIGGER_t mode)
5185 5186 5187 5188 5189
{
   uint8_t    size;
   uint8_t buffer[100];

   //Generate SidelinkUEInformation
5190
   if (((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&8192) > 0) && (destinationInfoList != NULL)) {//if SIB18 is available
5191 5192 5193
      size = do_SidelinkUEInformation(ctxt_pP->module_id, buffer, destinationInfoList, NULL, mode);
      LOG_I(RRC,"[UE %d][RRC_UE] Frame %d : Logical Channel UL-DCCH, Generating SidelinkUEInformation (bytes%d, eNB %d)\n",
            ctxt_pP->module_id,ctxt_pP->frame, size, eNB_index);
5194
      return size;
5195
   }
5196
   if (((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&16384) > 0) && (discTxResourceReq != NULL)) {//if SIB19 is available
5197 5198 5199
      size = do_SidelinkUEInformation(ctxt_pP->module_id, buffer, NULL, discTxResourceReq, mode);
      LOG_I(RRC,"[UE %d][RRC_UE] Frame %d : Logical Channel UL-DCCH, Generating SidelinkUEInformation (bytes%d, eNB %d)\n",
            ctxt_pP->module_id,ctxt_pP->frame, size, eNB_index);
5200
      return size;
5201
   }
5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221
}


// 3GPP 36.331 (Section 5.10.7.3)
uint8_t fill_SLSS(const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index, SLSSID_r12_t *slss_id, uint8_t *subframe, uint8_t mode)
{
   long syncOffsetIndicator = 0;
   switch(mode) {
   case 1: //if triggered by SL discovery announcement and in-coverage
      //discSyncConfig_r12 contains only one element
      *slss_id = UE_rrc_inst[ctxt_pP->module_id].sib19[eNB_index]->discConfig_r12->discSyncConfig_r12->list.array[0]->slssid_r12;
      syncOffsetIndicator = UE_rrc_inst[ctxt_pP->module_id].sib19[eNB_index]->discConfig_r12->discSyncConfig_r12->list.array[0]->syncOffsetIndicator_r12;
      //select subframe for SLSS
      break;
   case 2: //if triggered by SL communication and in-coverage

      if (UE_rrc_inst[ctxt_pP->module_id].sib18[eNB_index]->commConfig_r12->commSyncConfig_r12->list.array[0]->txParameters_r12) {
         *slss_id = UE_rrc_inst[ctxt_pP->module_id].sib18[eNB_index]->commConfig_r12->commSyncConfig_r12->list.array[0]->slssid_r12;
         syncOffsetIndicator = UE_rrc_inst[ctxt_pP->module_id].sib18[eNB_index]->commConfig_r12->commSyncConfig_r12->list.array[0]->syncOffsetIndicator_r12;

Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5222
         //if RRC_CONNECTED (Todo: and if networkControlledSyncTx (RRCConnectionReconfiguration) is configured and set to On)
5223 5224 5225 5226 5227 5228 5229 5230
         if (UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].State == RRC_CONNECTED){
            //select subframe(s) indicated by syncOffsetIndicator
            subframe = syncOffsetIndicator;
         } else {
            //select subframe(s) indicated by syncOffsetIndicator within SC period
         }
         break;
   case 3: //if triggered by V2X communication and in coverage
5231

5232 5233
      break;
   case 4: //if triggered by V2X communication and out-of-coverage
5234

5235 5236 5237 5238 5239 5240 5241
      break;
   case 5: //if triggered by V2X communication and UE has GNSS as the synchronization reference

   default:
      //if UE has a selected SyncRefUE
      //TODO
      //else (no SyncRefUE Selected)
5242 5243 5244 5245
      //Todo  if trigger by V2X
      //else randomly select an SLSSID from the set defined for out-of-coverage
      *slss_id = 170;//hardcoded
      //select the subframe according to syncOffsetIndicator1/2 from the preconfigured parameters
5246 5247 5248
      break;
      }
   }
5249 5250 5251 5252 5253 5254
   return 0;
}


//-----------------------------------------------------------------------------
void
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5255
rrc_ue_process_sidelink_radioResourceConfig(
5256 5257 5258 5259 5260 5261 5262 5263 5264
      module_id_t                      Mod_idP,
      uint8_t                          eNB_index,
      SystemInformationBlockType18_r12_t     *sib18,
      SystemInformationBlockType19_r12_t     *sib19,
      SL_CommConfig_r12_t* sl_CommConfig,
      SL_DiscConfig_r12_t* sl_DiscConfig
)
//-----------------------------------------------------------------------------
{
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5265
   //process SIB18, configure MAC/PHY for receiving SL communication (RRC_IDLE and RRC_CONNECTED), for transmitting SL communication (RRC_IDLE)
5266
   if (sib18 != NULL) {
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5267 5268 5269 5270 5271
      if (sib18->commConfig_r12 != NULL) {
         //do not consider commTXPoolExceptional for the moment
         //configure PHY/MAC to receive SL communication by using the RPs indicated by commRxPool
         //sib18->commConfig_r12->commRxPool_r12
         //we can configure a default SLRB to receive one-to-many communication [should be verified]
5272

Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5273 5274 5275 5276 5277 5278 5279

         if (sib18->commConfig_r12->commTxPoolNormalCommon_r12 !=NULL) { //commTxPoolNormalCommon - to transmit SL communication in RRC_IDLE
            //maybe we don't consider this case for the moment since UE will immediately establish a RRC connection after receiving SIB messages
            //configure PHY/MAC to transmit SL communication using the RPs indicated by the first entry in commTxPoolNormalCommon
            //SL_CommResourcePool_r12_t sl_CommResourcePool = sib18->commConfig_r12->commTxPoolNormalCommon_r12->list.array[0];
         }
      }
5280 5281
   }

Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5282
   //process SIB19, configure MAC/PHY for receiving SL discovery (RRC_IDLE and RRC_CONNECTED), for transmitting SL discovery (RRC_IDLE)
5283
   if (sib19 != NULL) {
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5284 5285 5286 5287 5288
      //to receive non-PS related discovery announcements (discRxPool)
      //sib19->discConfig_r12->discRxPool_r12;

      //to receive PS related discovery announcements (discRxPoolPS)
      //sib19->ext1->discConfigPS_13->discRxPoolPS_r13;
5289

Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5290 5291 5292 5293 5294
      //to transmit non-PS related discovery in RRC_IDLE
      //sib19->discConfig_r12->discTxPoolCommon_r12;

      //to transmit PS related discovery in RRC_IDLE
      //sib19->ext1->discConfigPS_13->discTxPoolPS_Common_r13;
5295
   }
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5296 5297

   //process sl_CommConfig, configure MAC/PHY for transmitting SL communication (RRC_CONNECTED)
5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320
   if (sl_CommConfig != NULL) {

      if (sl_CommConfig->commTxResources_r12 != NULL) {
         switch (sl_CommConfig->commTxResources_r12->present){
         case SL_CommConfig_r12__commTxResources_r12_PR_setup:
            if (sl_CommConfig->commTxResources_r12->choice.setup.present == SL_CommConfig_r12__commTxResources_r12__setup_PR_scheduled_r12 ){
               //configure scheduled resource for SL
               //sl_CommConfig->commTxResources_r12->choice.setup.choice.scheduled_r12.sl_RNTI_r12;
               //sl_CommConfig->commTxResources_r12->choice.setup.choice.scheduled_r12.mcs_r12;
               //sl_CommConfig->commTxResources_r12->choice.setup.choice.scheduled_r12.mac_MainConfig_r12;
               //sl_CommConfig->commTxResources_r12->choice.setup.choice.scheduled_r12.sc_CommTxConfig_r12;
            } else if (sl_CommConfig->commTxResources_r12->choice.setup.present == SL_CommConfig_r12__commTxResources_r12__setup_PR_ue_Selected_r12){
               //configure dedicated resources (commTxPoolNormalDedicated) for SL from which UE can autonomously select
               //sl_CommConfig->commTxResources_r12->choice.setup.choice.ue_Selected_r12.commTxPoolNormalDedicated_r12;

               //for the moment, only pass the first entry (e.g., do not consider priorityList in commTxPoolNormalDedicated (3GPP 36.331 Section 5.10.4 1>2>3>4))
               //sl_CommConfig->commTxResources_r12->choice.setup.choice.ue_Selected_r12.commTxPoolNormalDedicated_r12.poolToAddModList_r12->list.array[0];
            } else {
               //SL_CommConfig_r12__commTxResources_r12__setup_PR_NOTHING /* No components present */
            }
            break;

         case SL_CommConfig_r12__commTxResources_r12_PR_release:
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5321
            //release dedicated resources for SL communication
5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333
            break;

         case SL_CommConfig_r12__commTxResources_r12_PR_NOTHING: /* No components present */
            break;

         default:
            break;
         }
      }

   }

Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5334
   //process sl_DiscConfig, configure MAC/PHY for transmitting SL discovery announcements (RRC_CONNECTED)
5335
   if (sl_DiscConfig != NULL) {
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5336
      //dedicated resources for transmitting non-PS related discovery
5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351
      if (sl_DiscConfig->discTxResources_r12 != NULL) {

         switch (sl_DiscConfig->discTxResources_r12->present) {
         case SL_DiscConfig_r12__discTxResources_r12_PR_setup:
            if (sl_DiscConfig->discTxResources_r12->choice.setup.present == SL_DiscConfig_r12__discTxResources_r12__setup_PR_scheduled_r12) {
               //sl_DiscConfig->discTxResources_r12->choice.setup.choice.scheduled_r12.discHoppingConfig_r12;
               //sl_DiscConfig->discTxResources_r12->choice.setup.choice.scheduled_r12.discTF_IndexList_r12;
               //sl_DiscConfig->discTxResources_r12->choice.setup.choice.scheduled_r12.discTxConfig_r12;
            } else if (sl_DiscConfig->discTxResources_r12->choice.setup.present == SL_DiscConfig_r12__discTxResources_r12__setup_PR_ue_Selected_r12) {
               //sl_DiscConfig->discTxResources_r12->choice.setup.choice.ue_Selected_r12.discTxPoolDedicated_r12;
            } else {
               //SL_DiscConfig_r12__discTxResources_r12__setup_PR_NOTHING,   /* No components present */
            }
            break;
         case SL_DiscConfig_r12__discTxResources_r12_PR_release:
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5352
            //release dedicated resources for SL discovery
5353 5354 5355 5356 5357 5358 5359 5360
            break;
         case SL_DiscConfig_r12__discTxResources_r12_PR_NOTHING: /* No components present */
            break;
         default:
            break;
         }

      }
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383
      //dedicated resources for transmitting PS related discovery
      if (sl_DiscConfig->ext2->discTxResourcesPS_r13 != NULL){
         switch (sl_DiscConfig->ext2->discTxResourcesPS_r13->present) {
         case SL_DiscConfig_r12__ext2__discTxResourcesPS_r13_PR_setup:
            if (sl_DiscConfig->ext2->discTxResourcesPS_r13->choice.setup.present == SL_DiscConfig_r12__ext2__discTxResourcesPS_r13__setup_PR_scheduled_r13) {
               //sl_DiscConfig->ext2->discTxResourcesPS_r13->choice.setup.choice.scheduled_r13.discHoppingConfig_r13;
               //sl_DiscConfig->ext2->discTxResourcesPS_r13->choice.setup.choice.scheduled_r13.discTxConfig_r13
            } else if (sl_DiscConfig->ext2->discTxResourcesPS_r13->choice.setup.present == SL_DiscConfig_r12__ext2__discTxResourcesPS_r13__setup_PR_ue_Selected_r13) {
               //sl_DiscConfig->ext2->discTxResourcesPS_r13->choice.setup.choice.ue_Selected_r13.discTxPoolPS_Dedicated_r13;
            } else {
               //SL_DiscConfig_r12__ext2__discTxResourcesPS_r13__setup_PR_NOTHING, /* No components present */
            }

            break;
         case SL_DiscConfig_r12__ext2__discTxResourcesPS_r13_PR_release:
            break;
         case SL_DiscConfig_r12__ext2__discTxResourcesPS_r13_PR_NOTHING:
            /* No components present */
            break;
         default:
            break;
         }
      }
5384
   }
5385
}
5386

Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
5387
#ifdef Rel14
5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448
//-----------------------------------------------------------
void
rrc_control_socket_init(){

   struct sockaddr_in rrc_ctrl_socket_addr;
   pthread_attr_t     attr;
   struct sched_param sched_param;
   int optval; // flag value for setsockopt
   int n; // message byte size

   //init the mutex
   //pthread_mutex_init(&slrb_mutex, NULL);

   // create the control socket
   ctrl_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
   if (ctrl_sock_fd == -1) {
      LOG_E(RRC,"[rrc_control_socket_init] :Error opening socket %d (%d:%s)\n",ctrl_sock_fd,errno, strerror(errno));
      exit(EXIT_FAILURE);
   }
   //   if (ctrl_sock_fd < 0)
   //      error("ERROR: Failed on opening socket");
   optval = 1;
   setsockopt(ctrl_sock_fd, SOL_SOCKET, SO_REUSEADDR,
         (const void *)&optval , sizeof(int));

   //build the server's  address
   bzero((char *) &rrc_ctrl_socket_addr, sizeof(rrc_ctrl_socket_addr));
   rrc_ctrl_socket_addr.sin_family = AF_INET;
   rrc_ctrl_socket_addr.sin_addr.s_addr = htonl(INADDR_ANY);
   rrc_ctrl_socket_addr.sin_port = htons(CONTROL_SOCKET_PORT_NO);
   // associate the parent socket with a port
   if (bind(ctrl_sock_fd, (struct sockaddr *) &rrc_ctrl_socket_addr,
         sizeof(rrc_ctrl_socket_addr)) < 0) {
      LOG_E(RRC,"[rrc_control_socket_init] ERROR: Failed on binding the socket\n");
      exit(1);
   }
   //create thread to listen to incoming packets
   if (pthread_attr_init(&attr) != 0) {
      LOG_E(RRC, "[rrc_control_socket_init]Failed to initialize pthread attribute for ProSe -> RRC communication (%d:%s)\n",
            errno, strerror(errno));
      exit(EXIT_FAILURE);
   }

   sched_param.sched_priority = 10;

   pthread_attr_setschedpolicy(&attr, SCHED_RR);
   pthread_attr_setschedparam(&attr, &sched_param);

   pthread_t rrc_control_socket_thread;

   if (pthread_create(&rrc_control_socket_thread, &attr, rrc_control_socket_thread_fct, NULL) != 0) {
      LOG_E(RRC, "[rrc_control_socket_init]Failed to create new thread for RRC/ProSeApp communication (%d:%s)\n",
            errno, strerror(errno));
      exit(EXIT_FAILURE);
   }

   pthread_setname_np( rrc_control_socket_thread, "RRC Control Socket" );

}

//--------------------------------------------------------
5449
void *rrc_control_socket_thread_fct(void *arg)
5450 5451 5452 5453 5454
{

   int prose_addr_len;
   char send_buf[BUFSIZE];
   char receive_buf[BUFSIZE];
5455 5456
   int optval;
   int n;
5457 5458
   struct sidelink_ctrl_element *sl_ctrl_msg_recv = NULL;
   struct sidelink_ctrl_element *sl_ctrl_msg_send = NULL;
5459 5460
   uint32_t sourceL2Id, groupL2Id, destinationL2Id;
   module_id_t         module_id = 0; //hardcoded for testing only
5461
   uint8_t type;
5462 5463 5464 5465 5466 5467 5468 5469
   UE_RRC_INST *UE  = NULL;
   protocol_ctxt_t ctxt;
   struct RLC_Config                  *DRB_rlc_config                   = NULL;
   struct PDCP_Config                 *DRB_pdcp_config                  = NULL;
   struct PDCP_Config__rlc_UM         *PDCP_rlc_UM                      = NULL;
   struct LogicalChannelConfig        *DRB_lchan_config                 = NULL;
   struct LogicalChannelConfig__ul_SpecificParameters  *DRB_ul_SpecificParameters = NULL;
   long                               *logicalchannelgroup_drb          = NULL;
5470 5471
   int j = 0;
   int i = 0;
5472 5473 5474 5475 5476

   //from the main program, listen for the incoming messages from control socket (ProSe App)
   prose_addr_len = sizeof(prose_app_addr);
   int enable_notification = 1;
   while (1) {
5477
      LOG_I(RRC,"Listening to incoming connection from ProSe App \n");
5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495
      // receive a message from ProSe App
      memset(receive_buf, 0, BUFSIZE);
      n = recvfrom(ctrl_sock_fd, receive_buf, BUFSIZE, 0,
            (struct sockaddr *) &prose_app_addr, &prose_addr_len);
      if (n < 0){
         LOG_E(RRC, "ERROR: Failed to receive from ProSe App\n");
         exit(EXIT_FAILURE);
      }
      //TODO: should store the address of ProSeApp [UE_rrc_inst] to be able to send UE state notification to the App

      //sl_ctrl_msg_recv = (struct sidelink_ctrl_element *) receive_buf;
      sl_ctrl_msg_recv = calloc(1, sizeof(struct sidelink_ctrl_element));
      memcpy((void *)sl_ctrl_msg_recv, (void *)receive_buf, sizeof(struct sidelink_ctrl_element));

      //process the message
      switch (sl_ctrl_msg_recv->type) {
      case SESSION_INIT_REQ:
#ifdef DEBUG_CTRL_SOCKET
5496
         LOG_I(RRC,"Received SessionInitializationRequest on socket from ProSe App (msg type: %d)\n", sl_ctrl_msg_recv->type);
5497 5498 5499
#endif
         //TODO: get SL_UE_STATE from lower layer

5500
         LOG_I(RRC,"Send UEStateInformation to ProSe App \n");
5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519
         memset(send_buf, 0, BUFSIZE);

         sl_ctrl_msg_send = calloc(1, sizeof(struct sidelink_ctrl_element));
         sl_ctrl_msg_send->type = UE_STATUS_INFO;
         sl_ctrl_msg_send->sidelinkPrimitive.ue_state = UE_STATE_OFF_NETWORK; //off-network
         memcpy((void *)send_buf, (void *)sl_ctrl_msg_send, sizeof(struct sidelink_ctrl_element));
         free(sl_ctrl_msg_send);

         prose_addr_len = sizeof(prose_app_addr);
         n = sendto(ctrl_sock_fd, (char *)send_buf, sizeof(struct sidelink_ctrl_element), 0, (struct sockaddr *)&prose_app_addr, prose_addr_len);
         if (n < 0) {
            LOG_E(RRC, "ERROR: Failed to send to ProSe App\n");
            exit(EXIT_FAILURE);
         }


#ifdef DEBUG_CTRL_SOCKET
         struct sidelink_ctrl_element *ptr_ctrl_msg = NULL;
         ptr_ctrl_msg = (struct sidelink_ctrl_element *) send_buf;
5520 5521
         LOG_I(RRC,"[UEStateInformation] msg type: %d\n",ptr_ctrl_msg->type);
         LOG_I(RRC,"[UEStateInformation] UE state: %d\n",ptr_ctrl_msg->sidelinkPrimitive.ue_state);
5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534
#endif

         /*  if (enable_notification > 0) {
              //create thread to send status notification (for testing purpose, status notification will be sent e.g., every 20 seconds)
              pthread_t notification_thread;
              if( pthread_create( &notification_thread , NULL ,  send_UE_status_notification , (void*) &sockfd) < 0)
                 error("ERROR: could not create thread");
           }
           enable_notification = 0;
          */
         break;

      case GROUP_COMMUNICATION_ESTABLISH_REQ:
5535 5536
         sourceL2Id = sl_ctrl_msg_recv->sidelinkPrimitive.group_comm_establish_req.sourceL2Id;
         groupL2Id = sl_ctrl_msg_recv->sidelinkPrimitive.group_comm_establish_req.groupL2Id;
5537

5538
#ifdef DEBUG_CTRL_SOCKET
5539
         LOG_I(RRC,"[GroupCommunicationEstablishReq] Received on socket from ProSe App (msg type: %d)\n",sl_ctrl_msg_recv->type);
5540 5541
         LOG_I(RRC,"[GroupCommunicationEstablishReq] source Id: 0x%08x\n",sl_ctrl_msg_recv->sidelinkPrimitive.group_comm_establish_req.sourceL2Id);
         LOG_I(RRC,"[GroupCommunicationEstablishReq] group Id: 0x%08x\n",sl_ctrl_msg_recv->sidelinkPrimitive.group_comm_establish_req.groupL2Id);
5542
         LOG_I(RRC,"[GroupCommunicationEstablishReq] group IP Address: " IPV4_ADDR "\n",IPV4_ADDR_FORMAT(sl_ctrl_msg_recv->sidelinkPrimitive.group_comm_establish_req.groupIpAddress));
5543
#endif
5544

5545
         //store sourceL2Id/groupL2Id
5546 5547
         UE_rrc_inst[module_id].sourceL2Id = sourceL2Id;
         UE_rrc_inst[module_id].groupL2Id = groupL2Id;
5548 5549
         j = 0;
         i = 0;
5550 5551 5552 5553 5554 5555
         for (i=0; i< MAX_NUM_DEST; i++) {
            if ((UE_rrc_inst[module_id].destinationList[i] == 0) && (j == 0)) j = i+1;
            if (UE_rrc_inst[module_id].destinationList[i] == groupL2Id) break; //group already exists!
         }
         if ((i == MAX_NUM_DEST) && (j > 0))  UE_mac_inst[module_id].destinationList[j-1] = groupL2Id;

5556
         // configure lower layers PDCP/MAC/PHY for this communication
5557 5558
         //Establish a new RBID/LCID for this communication
         // Establish a SLRB (using DRB 3 for now)
5559
         UE  = &UE_rrc_inst[module_id];
5560 5561 5562 5563 5564 5565 5566 5567 5568 5569
         PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, 0, ENB_FLAG_NO, 0x1234, 0, 0,0);

         UE->DRB_config[0][0] = CALLOC(1,sizeof(struct DRB_ToAddMod));
         UE->DRB_config[0][0]->eps_BearerIdentity = CALLOC(1, sizeof(long));
         UE->DRB_config[0][0]->drb_Identity =  3;
         UE->DRB_config[0][0]->eps_BearerIdentity = CALLOC(1, sizeof(long));
         // allowed value 5..15, value : x+4
         *(UE->DRB_config[0][0]->eps_BearerIdentity) = 3;
         UE->DRB_config[0][0]->logicalChannelIdentity = CALLOC(1, sizeof(long));
         *(UE->DRB_config[0][0]->logicalChannelIdentity) = UE->DRB_config[0][0]->drb_Identity; //(long) (ue_context_pP->ue_context.e_rab[i].param.e_rab_id + 2); // value : x+2
5570

5571 5572 5573 5574 5575 5576
         DRB_rlc_config                   = CALLOC(1,sizeof(struct RLC_Config));
         DRB_pdcp_config                  = CALLOC(1,sizeof(struct PDCP_Config));
         PDCP_rlc_UM                      = CALLOC(1,sizeof(struct PDCP_Config__rlc_UM));
         DRB_lchan_config                 = CALLOC(1,sizeof(struct LogicalChannelConfig));
         DRB_ul_SpecificParameters                                         = CALLOC(1, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
         logicalchannelgroup_drb          = CALLOC(1, sizeof(long));
5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625

         DRB_rlc_config->present = RLC_Config_PR_um_Bi_Directional;
         DRB_rlc_config->choice.um_Bi_Directional.ul_UM_RLC.sn_FieldLength = SN_FieldLength_size10;
         DRB_rlc_config->choice.um_Bi_Directional.dl_UM_RLC.sn_FieldLength = SN_FieldLength_size10;
         DRB_rlc_config->choice.um_Bi_Directional.dl_UM_RLC.t_Reordering = T_Reordering_ms35;
         UE->DRB_config[0][0]->rlc_Config = DRB_rlc_config;

         DRB_pdcp_config = CALLOC(1, sizeof(*DRB_pdcp_config));
         UE->DRB_config[0][0]->pdcp_Config = DRB_pdcp_config;
         DRB_pdcp_config->discardTimer = CALLOC(1, sizeof(long));
         *DRB_pdcp_config->discardTimer = PDCP_Config__discardTimer_infinity;
         DRB_pdcp_config->rlc_AM = NULL;
         DRB_pdcp_config->rlc_UM = NULL;

         /* avoid gcc warnings */
         (void)PDCP_rlc_UM;

         DRB_pdcp_config->rlc_UM = PDCP_rlc_UM;
         PDCP_rlc_UM->pdcp_SN_Size = PDCP_Config__rlc_UM__pdcp_SN_Size_len12bits;
         DRB_pdcp_config->headerCompression.present = PDCP_Config__headerCompression_PR_notUsed;

         UE->DRB_config[0][0]->logicalChannelConfig = DRB_lchan_config;
         DRB_ul_SpecificParameters = CALLOC(1, sizeof(*DRB_ul_SpecificParameters));
         DRB_lchan_config->ul_SpecificParameters = DRB_ul_SpecificParameters;

         DRB_ul_SpecificParameters->priority = 12;    // lower priority than srb1, srb2 and other dedicated bearer
         DRB_ul_SpecificParameters->prioritisedBitRate =LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_kBps8 ;
         //LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_infinity;
         DRB_ul_SpecificParameters->bucketSizeDuration =
               LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms50;

         // LCG for DTCH can take the value from 1 to 3 as defined in 36331: normally controlled by upper layers (like RRM)

         *logicalchannelgroup_drb = 1;
         DRB_ul_SpecificParameters->logicalChannelGroup = logicalchannelgroup_drb;

         UE->DRB_configList = CALLOC(1,sizeof(DRB_ToAddModList_t));
         ASN_SEQUENCE_ADD(&UE->DRB_configList->list,UE->DRB_config[0][0]);

         rrc_pdcp_config_asn1_req(&ctxt,
               (SRB_ToAddModList_t *) NULL,
               UE->DRB_configList,
               (DRB_ToReleaseList_t*) NULL,
               0xff, NULL, NULL, NULL
#if defined(Rel10) || defined(Rel14)
               , (PMCH_InfoList_r9_t *) NULL
#endif
               ,NULL);

5626

5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648
         rrc_rlc_config_asn1_req(&ctxt,
               (SRB_ToAddModList_t*)NULL,
               UE->DRB_configList,
               (DRB_ToReleaseList_t*)NULL
#if defined(Rel10) || defined(Rel14)
               ,(PMCH_InfoList_r9_t *)NULL
               , 0, 0
#endif
         );

         rrc_rlc_config_asn1_req(&ctxt,
               (SRB_ToAddModList_t*)NULL,
               UE->DRB_configList,
               (DRB_ToReleaseList_t*)NULL
#ifdef Rel14
               ,(PMCH_InfoList_r9_t *)NULL
               , sourceL2Id, groupL2Id
#endif
         );


         //configure MAC with sourceL2Id/groupL2ID
5649
         rrc_mac_config_req_ue(module_id,0,0, //eNB_index =0
5650 5651 5652 5653 5654 5655 5656 5657
               (RadioResourceConfigCommonSIB_t *)NULL,
               (struct PhysicalConfigDedicated *)NULL,
#if defined(Rel10) || defined(Rel14)
               (SCellToAddMod_r10_t *)NULL,
               //struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10,
#endif
               (MeasObjectToAddMod_t **)NULL,
               (MAC_MainConfig_t *)NULL,
5658
               3, //LCID
5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685
               (struct LogicalChannelConfig *)NULL,
               (MeasGapConfig_t *)NULL,
               (TDD_Config_t *)NULL,
               (MobilityControlInfo_t *)NULL,
               NULL,
               NULL,
               NULL,
               NULL,
               NULL,
               NULL
#if defined(Rel10) || defined(Rel14)
               ,0,
               (MBSFN_AreaInfoList_r9_t *)NULL,
               (PMCH_InfoList_r9_t *)NULL

#endif
#ifdef CBA
               ,
               0,
               0
#endif
#if defined(Rel10) || defined(Rel14)
               ,CONFIG_ACTION_ADD,
               &sourceL2Id,
               &groupL2Id
#endif
         );
5686

5687
         LOG_I(RRC,"Send GroupCommunicationEstablishResp to ProSe App\n");
5688 5689 5690
         memset(send_buf, 0, BUFSIZE);
         sl_ctrl_msg_send = calloc(1, sizeof(struct sidelink_ctrl_element));
         sl_ctrl_msg_send->type = GROUP_COMMUNICATION_ESTABLISH_RSP;
5691
         sl_ctrl_msg_send->sidelinkPrimitive.slrb_id = 3; //slrb_id
5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705

         memcpy((void *)send_buf, (void *)sl_ctrl_msg_send, sizeof(struct sidelink_ctrl_element));
         free(sl_ctrl_msg_send);

         prose_addr_len = sizeof(prose_app_addr);
         n = sendto(ctrl_sock_fd, (char *)send_buf, sizeof(struct sidelink_ctrl_element), 0, (struct sockaddr *)&prose_app_addr, prose_addr_len);
         if (n < 0){
            LOG_E(RRC, "ERROR: Failed to send to ProSe App\n");
            exit(EXIT_FAILURE);
         }


#ifdef DEBUG_CTRL_SOCKET
         ptr_ctrl_msg = (struct sidelink_ctrl_element *) send_buf;
5706 5707
         LOG_I(RRC,"[GroupCommunicationEstablishResponse]  msg type: %d\n",ptr_ctrl_msg->type);
         LOG_I(RRC,"[GroupCommunicationEstablishResponse]  slrb_id: %d\n",ptr_ctrl_msg->sidelinkPrimitive.slrb_id);
5708 5709
#endif
         break;
5710

5711 5712 5713
      case GROUP_COMMUNICATION_RELEASE_REQ:
         printf("-----------------------------------\n");
#ifdef DEBUG_CTRL_SOCKET
5714 5715
         LOG_I(RRC,"[GroupCommunicationReleaseRequest] Received on socket from ProSe App (msg type: %d)\n",sl_ctrl_msg_recv->type);
         LOG_I(RRC,"[GroupCommunicationReleaseRequest] Slrb Id: %i\n",sl_ctrl_msg_recv->sidelinkPrimitive.slrb_id);
5716
#endif
5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752
         //reset groupL2ID from MAC LAYER
         UE_rrc_inst[module_id].groupL2Id = 0x00000000;
         sourceL2Id = UE_rrc_inst[module_id].sourceL2Id;

         rrc_mac_config_req_ue(module_id,0,0, //eNB_index =0
                    (RadioResourceConfigCommonSIB_t *)NULL,
                    (struct PhysicalConfigDedicated *)NULL,
         #if defined(Rel10) || defined(Rel14)
                    (SCellToAddMod_r10_t *)NULL,
                    //struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10,
         #endif
                    (MeasObjectToAddMod_t **)NULL,
                    (MAC_MainConfig_t *)NULL,
                    0,
                    (struct LogicalChannelConfig *)NULL,
                    (MeasGapConfig_t *)NULL,
                    (TDD_Config_t *)NULL,
                    (MobilityControlInfo_t *)NULL,
                    NULL,
                    NULL,
                    NULL,
                    NULL,
                    NULL,
                    NULL
         #if defined(Rel10) || defined(Rel14)
                    ,0,
                    (MBSFN_AreaInfoList_r9_t *)NULL,
                    (PMCH_InfoList_r9_t *)NULL

         #endif
         #ifdef CBA
                    ,
                    0,
                    0
         #endif
         #if defined(Rel10) || defined(Rel14)
5753
                    ,CONFIG_ACTION_REMOVE,
5754
                    &sourceL2Id,
5755
                    &destinationL2Id
5756 5757 5758 5759
         #endif
                    );


5760
         LOG_I(RRC,"Send GroupCommunicationReleaseResponse to ProSe App \n");
5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784
         memset(send_buf, 0, BUFSIZE);

         sl_ctrl_msg_send = calloc(1, sizeof(struct sidelink_ctrl_element));
         sl_ctrl_msg_send->type = GROUP_COMMUNICATION_RELEASE_RSP;
         //if the requested id exists -> release this ID
         if (sl_ctrl_msg_recv->sidelinkPrimitive.slrb_id == slrb_id) {
            sl_ctrl_msg_send->sidelinkPrimitive.group_comm_release_rsp = GROUP_COMMUNICATION_RELEASE_OK;
            // pthread_mutex_lock(&slrb_mutex);
            slrb_id = 0; //Reset slrb_id
            //pthread_mutex_unlock(&slrb_mutex);
         } else {
            sl_ctrl_msg_send->sidelinkPrimitive.group_comm_release_rsp = GROUP_COMMUNICATION_RELEASE_FAILURE;
         }
         memcpy((void *)send_buf, (void *)sl_ctrl_msg_send, sizeof(struct sidelink_ctrl_element));
         free(sl_ctrl_msg_send);

         prose_addr_len = sizeof(prose_app_addr);
         n = sendto(ctrl_sock_fd, (char *)send_buf, sizeof(struct sidelink_ctrl_element), 0, (struct sockaddr *)&prose_app_addr, prose_addr_len);
         if (n < 0){
            LOG_E(RRC, "ERROR: Failed to send to ProSe App\n");
            exit(EXIT_FAILURE);
         }
         break;

5785

5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960
      case DIRECT_COMMUNICATION_ESTABLISH_REQ:
         sourceL2Id = sl_ctrl_msg_recv->sidelinkPrimitive.direct_comm_establish_req.sourceL2Id;
         destinationL2Id = sl_ctrl_msg_recv->sidelinkPrimitive.direct_comm_establish_req.destinationL2Id;

#ifdef DEBUG_CTRL_SOCKET
         LOG_I(RRC,"[DirectCommunicationEstablishReq] Received on socket from ProSe App (msg type: %d)\n",sl_ctrl_msg_recv->type);
         LOG_I(RRC,"[DirectCommunicationEstablishReq] source Id: 0x%08x\n",sl_ctrl_msg_recv->sidelinkPrimitive.group_comm_establish_req.sourceL2Id);
         LOG_I(RRC,"[DirectCommunicationEstablishReq] destination Id: 0x%08x\n",sl_ctrl_msg_recv->sidelinkPrimitive.group_comm_establish_req.groupL2Id);
#endif

         //store sourceL2Id/destinationL2Id
         UE_rrc_inst[module_id].sourceL2Id = sourceL2Id;
         i = 0;
         j = 0;
         for (i=0; i< MAX_NUM_DEST; i++) {
            if ((UE_rrc_inst[module_id].destinationList[i] == 0) && (j == 0)) j = i+1;
            if (UE_rrc_inst[module_id].destinationList[i] == destinationL2Id) break; //destination already exists!
         }
         if ((i == MAX_NUM_DEST) && (j > 0))  UE_mac_inst[module_id].destinationList[j-1] = destinationL2Id;

         // configure lower layers PDCP/MAC/PHY for this communication
         //Establish a new RBID/LCID for this communication
         // Establish a SLRB (using DRB 3 for now)
         UE  = &UE_rrc_inst[module_id];
         PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, 0, ENB_FLAG_NO, 0x1234, 0, 0,0);

         UE->DRB_config[0][0] = CALLOC(1,sizeof(struct DRB_ToAddMod));
         UE->DRB_config[0][0]->eps_BearerIdentity = CALLOC(1, sizeof(long));
         UE->DRB_config[0][0]->drb_Identity =  3;
         UE->DRB_config[0][0]->eps_BearerIdentity = CALLOC(1, sizeof(long));
         // allowed value 5..15, value : x+4
         *(UE->DRB_config[0][0]->eps_BearerIdentity) = 3;
         UE->DRB_config[0][0]->logicalChannelIdentity = CALLOC(1, sizeof(long));
         *(UE->DRB_config[0][0]->logicalChannelIdentity) = UE->DRB_config[0][0]->drb_Identity; //(long) (ue_context_pP->ue_context.e_rab[i].param.e_rab_id + 2); // value : x+2

         DRB_rlc_config                   = CALLOC(1,sizeof(struct RLC_Config));
         DRB_pdcp_config                  = CALLOC(1,sizeof(struct PDCP_Config));
         PDCP_rlc_UM                      = CALLOC(1,sizeof(struct PDCP_Config__rlc_UM));
         DRB_lchan_config                 = CALLOC(1,sizeof(struct LogicalChannelConfig));
         DRB_ul_SpecificParameters                                         = CALLOC(1, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
         logicalchannelgroup_drb          = CALLOC(1, sizeof(long));

         DRB_rlc_config->present = RLC_Config_PR_um_Bi_Directional;
         DRB_rlc_config->choice.um_Bi_Directional.ul_UM_RLC.sn_FieldLength = SN_FieldLength_size10;
         DRB_rlc_config->choice.um_Bi_Directional.dl_UM_RLC.sn_FieldLength = SN_FieldLength_size10;
         DRB_rlc_config->choice.um_Bi_Directional.dl_UM_RLC.t_Reordering = T_Reordering_ms35;
         UE->DRB_config[0][0]->rlc_Config = DRB_rlc_config;

         DRB_pdcp_config = CALLOC(1, sizeof(*DRB_pdcp_config));
         UE->DRB_config[0][0]->pdcp_Config = DRB_pdcp_config;
         DRB_pdcp_config->discardTimer = CALLOC(1, sizeof(long));
         *DRB_pdcp_config->discardTimer = PDCP_Config__discardTimer_infinity;
         DRB_pdcp_config->rlc_AM = NULL;
         DRB_pdcp_config->rlc_UM = NULL;

         /* avoid gcc warnings */
         (void)PDCP_rlc_UM;

         DRB_pdcp_config->rlc_UM = PDCP_rlc_UM;
         PDCP_rlc_UM->pdcp_SN_Size = PDCP_Config__rlc_UM__pdcp_SN_Size_len12bits;
         DRB_pdcp_config->headerCompression.present = PDCP_Config__headerCompression_PR_notUsed;

         UE->DRB_config[0][0]->logicalChannelConfig = DRB_lchan_config;
         DRB_ul_SpecificParameters = CALLOC(1, sizeof(*DRB_ul_SpecificParameters));
         DRB_lchan_config->ul_SpecificParameters = DRB_ul_SpecificParameters;

         DRB_ul_SpecificParameters->priority = 12;    // lower priority than srb1, srb2 and other dedicated bearer
         DRB_ul_SpecificParameters->prioritisedBitRate =LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_kBps8 ;
         //LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_infinity;
         DRB_ul_SpecificParameters->bucketSizeDuration =
               LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms50;

         // LCG for DTCH can take the value from 1 to 3 as defined in 36331: normally controlled by upper layers (like RRM)

         *logicalchannelgroup_drb = 1;
         DRB_ul_SpecificParameters->logicalChannelGroup = logicalchannelgroup_drb;

         UE->DRB_configList = CALLOC(1,sizeof(DRB_ToAddModList_t));
         ASN_SEQUENCE_ADD(&UE->DRB_configList->list,UE->DRB_config[0][0]);

         rrc_pdcp_config_asn1_req(&ctxt,
               (SRB_ToAddModList_t *) NULL,
               UE->DRB_configList,
               (DRB_ToReleaseList_t*) NULL,
               0xff, NULL, NULL, NULL
#if defined(Rel10) || defined(Rel14)
               , (PMCH_InfoList_r9_t *) NULL
#endif
               ,NULL);


         rrc_rlc_config_asn1_req(&ctxt,
               (SRB_ToAddModList_t*)NULL,
               UE->DRB_configList,
               (DRB_ToReleaseList_t*)NULL
#if defined(Rel10) || defined(Rel14)
               ,(PMCH_InfoList_r9_t *)NULL
               , 0, 0
#endif
         );

         rrc_rlc_config_asn1_req(&ctxt,
               (SRB_ToAddModList_t*)NULL,
               UE->DRB_configList,
               (DRB_ToReleaseList_t*)NULL
#ifdef Rel14
               ,(PMCH_InfoList_r9_t *)NULL
               , sourceL2Id, destinationL2Id
#endif
         );


         //configure MAC with sourceL2Id/destinationL2Id
         rrc_mac_config_req_ue(module_id,0,0, //eNB_index =0
               (RadioResourceConfigCommonSIB_t *)NULL,
               (struct PhysicalConfigDedicated *)NULL,
#if defined(Rel10) || defined(Rel14)
               (SCellToAddMod_r10_t *)NULL,
               //struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10,
#endif
               (MeasObjectToAddMod_t **)NULL,
               (MAC_MainConfig_t *)NULL,
               3, //LCID
               (struct LogicalChannelConfig *)NULL,
               (MeasGapConfig_t *)NULL,
               (TDD_Config_t *)NULL,
               (MobilityControlInfo_t *)NULL,
               NULL,
               NULL,
               NULL,
               NULL,
               NULL,
               NULL
#if defined(Rel10) || defined(Rel14)
               ,0,
               (MBSFN_AreaInfoList_r9_t *)NULL,
               (PMCH_InfoList_r9_t *)NULL

#endif
#ifdef CBA
               ,
               0,
               0
#endif
#if defined(Rel10) || defined(Rel14)
               ,CONFIG_ACTION_ADD,
               &sourceL2Id,
               &destinationL2Id
#endif
         );

         LOG_I(RRC,"Send DirectCommunicationEstablishResp to ProSe App\n");
         memset(send_buf, 0, BUFSIZE);
         sl_ctrl_msg_send = calloc(1, sizeof(struct sidelink_ctrl_element));
         sl_ctrl_msg_send->type = DIRECT_COMMUNICATION_ESTABLISH_RSP;
         sl_ctrl_msg_send->sidelinkPrimitive.slrb_id = 3; //slrb_id

         memcpy((void *)send_buf, (void *)sl_ctrl_msg_send, sizeof(struct sidelink_ctrl_element));
         free(sl_ctrl_msg_send);

         prose_addr_len = sizeof(prose_app_addr);
         n = sendto(ctrl_sock_fd, (char *)send_buf, sizeof(struct sidelink_ctrl_element), 0, (struct sockaddr *)&prose_app_addr, prose_addr_len);
         if (n < 0){
            LOG_E(RRC, "ERROR: Failed to send to ProSe App\n");
            exit(EXIT_FAILURE);
         }


#ifdef DEBUG_CTRL_SOCKET
         ptr_ctrl_msg = (struct sidelink_ctrl_element *) send_buf;
         LOG_I(RRC,"[DirectCommunicationEstablishResponse]  msg type: %d\n",ptr_ctrl_msg->type);
         LOG_I(RRC,"[DirectCommunicationEstablishResponse]  slrb_id: %d\n",ptr_ctrl_msg->sidelinkPrimitive.slrb_id);
#endif
         break;

5961
      case PC5S_ESTABLISH_REQ:
5962
         type =  sl_ctrl_msg_recv->sidelinkPrimitive.pc5s_establish_req.type;
5963
         sourceL2Id = sl_ctrl_msg_recv->sidelinkPrimitive.pc5s_establish_req.sourceL2Id;
5964 5965 5966 5967
#ifdef DEBUG_CTRL_SOCKET
         LOG_I(RRC,"[PC5EstablishReq] Received on socket from ProSe App (msg type: %d)\n",sl_ctrl_msg_recv->type);
         LOG_I(RRC,"[PC5EstablishReq] type: %d\n",sl_ctrl_msg_recv->sidelinkPrimitive.pc5s_establish_req.type); //RX/TX
         LOG_I(RRC,"[PC5EstablishReq] source Id: 0x%08x \n",sl_ctrl_msg_recv->sidelinkPrimitive.pc5s_establish_req.sourceL2Id);
5968 5969 5970
#endif
         if (type > 0) {
            destinationL2Id = sl_ctrl_msg_recv->sidelinkPrimitive.pc5s_establish_req.destinationL2Id;
5971
#ifdef DEBUG_CTRL_SOCKET
5972
            LOG_I(RRC,"[PC5EstablishReq] destination Id: 0x%08x \n",sl_ctrl_msg_recv->sidelinkPrimitive.pc5s_establish_req.destinationL2Id);
5973
#endif
5974 5975
         }

5976 5977 5978
         //store sourceL2Id/destinationL2Id
         if (type > 0) { //TX
            UE_rrc_inst[module_id].sourceL2Id = sourceL2Id;
5979 5980
            j = 0;
            i = 0;
5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992
            for (i=0; i< MAX_NUM_DEST; i++) {
               if ((UE_rrc_inst[module_id].destinationList[i] == 0) && (j == 0)) j = i+1;
               if (UE_rrc_inst[module_id].destinationList[i] == destinationL2Id) break; //group already exists!
            }
            if ((i == MAX_NUM_DEST) && (j > 0))  UE_mac_inst[module_id].destinationList[j-1] = destinationL2Id;
         } else {//RX
            UE_rrc_inst[module_id].sourceL2Id = sourceL2Id;
         }

         // configure lower layers PDCP/MAC/PHY for this communication
         //Establish a new RBID/LCID for this communication
         // Establish a SLRB (using DRB 10 for now)
5993
         UE  = &UE_rrc_inst[module_id];
5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078
         PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, 0, ENB_FLAG_NO, 0x1234, 0, 0,0);

         UE->DRB_config[0][0] = CALLOC(1,sizeof(struct DRB_ToAddMod));
         UE->DRB_config[0][0]->eps_BearerIdentity = CALLOC(1, sizeof(long));
         UE->DRB_config[0][0]->drb_Identity =  10;
         UE->DRB_config[0][0]->eps_BearerIdentity = CALLOC(1, sizeof(long));
         // allowed value 5..15, value : x+4
         *(UE->DRB_config[0][0]->eps_BearerIdentity) = 10;
         UE->DRB_config[0][0]->logicalChannelIdentity = CALLOC(1, sizeof(long));
         *(UE->DRB_config[0][0]->logicalChannelIdentity) = UE->DRB_config[0][0]->drb_Identity; //(long) (ue_context_pP->ue_context.e_rab[i].param.e_rab_id + 2); // value : x+2

         DRB_rlc_config                   = CALLOC(1,sizeof(struct RLC_Config));
         DRB_pdcp_config                  = CALLOC(1,sizeof(struct PDCP_Config));
         PDCP_rlc_UM                      = CALLOC(1,sizeof(struct PDCP_Config__rlc_UM));
         DRB_lchan_config                 = CALLOC(1,sizeof(struct LogicalChannelConfig));
         DRB_ul_SpecificParameters                                         = CALLOC(1, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
         logicalchannelgroup_drb          = CALLOC(1, sizeof(long));

         DRB_rlc_config->present = RLC_Config_PR_um_Bi_Directional;
         DRB_rlc_config->choice.um_Bi_Directional.ul_UM_RLC.sn_FieldLength = SN_FieldLength_size10;
         DRB_rlc_config->choice.um_Bi_Directional.dl_UM_RLC.sn_FieldLength = SN_FieldLength_size10;
         DRB_rlc_config->choice.um_Bi_Directional.dl_UM_RLC.t_Reordering = T_Reordering_ms35;
         UE->DRB_config[0][0]->rlc_Config = DRB_rlc_config;

         DRB_pdcp_config = CALLOC(1, sizeof(*DRB_pdcp_config));
         UE->DRB_config[0][0]->pdcp_Config = DRB_pdcp_config;
         DRB_pdcp_config->discardTimer = CALLOC(1, sizeof(long));
         *DRB_pdcp_config->discardTimer = PDCP_Config__discardTimer_infinity;
         DRB_pdcp_config->rlc_AM = NULL;
         DRB_pdcp_config->rlc_UM = NULL;

         /* avoid gcc warnings */
         (void)PDCP_rlc_UM;

         DRB_pdcp_config->rlc_UM = PDCP_rlc_UM;
         PDCP_rlc_UM->pdcp_SN_Size = PDCP_Config__rlc_UM__pdcp_SN_Size_len12bits;
         DRB_pdcp_config->headerCompression.present = PDCP_Config__headerCompression_PR_notUsed;

         UE->DRB_config[0][0]->logicalChannelConfig = DRB_lchan_config;
         DRB_ul_SpecificParameters = CALLOC(1, sizeof(*DRB_ul_SpecificParameters));
         DRB_lchan_config->ul_SpecificParameters = DRB_ul_SpecificParameters;

         DRB_ul_SpecificParameters->priority = 12;    // lower priority than srb1, srb2 and other dedicated bearer
         DRB_ul_SpecificParameters->prioritisedBitRate =LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_kBps8 ;
         //LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_infinity;
         DRB_ul_SpecificParameters->bucketSizeDuration =
               LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms50;

         // LCG for DTCH can take the value from 1 to 3 as defined in 36331: normally controlled by upper layers (like RRM)

         *logicalchannelgroup_drb = 1;
         DRB_ul_SpecificParameters->logicalChannelGroup = logicalchannelgroup_drb;

         UE->DRB_configList = CALLOC(1,sizeof(DRB_ToAddModList_t));
         ASN_SEQUENCE_ADD(&UE->DRB_configList->list,UE->DRB_config[0][0]);

         rrc_pdcp_config_asn1_req(&ctxt,
               (SRB_ToAddModList_t *) NULL,
               UE->DRB_configList,
               (DRB_ToReleaseList_t*) NULL,
               0xff, NULL, NULL, NULL
#if defined(Rel10) || defined(Rel14)
               , (PMCH_InfoList_r9_t *) NULL
#endif
               ,NULL);


         rrc_rlc_config_asn1_req(&ctxt,
               (SRB_ToAddModList_t*)NULL,
               UE->DRB_configList,
               (DRB_ToReleaseList_t*)NULL
#if defined(Rel10) || defined(Rel14)
               ,(PMCH_InfoList_r9_t *)NULL
               , 0, 0
#endif
         );

         //TX
         if (type > 0) {
            rrc_rlc_config_asn1_req(&ctxt,
                  (SRB_ToAddModList_t*)NULL,
                  UE->DRB_configList,
                  (DRB_ToReleaseList_t*)NULL
#ifdef Rel14
                  ,(PMCH_InfoList_r9_t *)NULL
6079
                  , sourceL2Id, destinationL2Id
6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117
#endif
            );

            //configure MAC with sourceL2Id/groupL2ID
            rrc_mac_config_req_ue(module_id,0,0, //eNB_index =0
                  (RadioResourceConfigCommonSIB_t *)NULL,
                  (struct PhysicalConfigDedicated *)NULL,
#if defined(Rel10) || defined(Rel14)
                  (SCellToAddMod_r10_t *)NULL,
                  //struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10,
#endif
                  (MeasObjectToAddMod_t **)NULL,
                  (MAC_MainConfig_t *)NULL,
                  10, //LCID
                  (struct LogicalChannelConfig *)NULL,
                  (MeasGapConfig_t *)NULL,
                  (TDD_Config_t *)NULL,
                  (MobilityControlInfo_t *)NULL,
                  NULL,
                  NULL,
                  NULL,
                  NULL,
                  NULL,
                  NULL
#if defined(Rel10) || defined(Rel14)
                  ,0,
                  (MBSFN_AreaInfoList_r9_t *)NULL,
                  (PMCH_InfoList_r9_t *)NULL

#endif
#ifdef CBA
                  ,
                  0,
                  0
#endif
#if defined(Rel10) || defined(Rel14)
                  ,CONFIG_ACTION_ADD,
                  &sourceL2Id,
6118
                  &destinationL2Id
6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131
#endif
            );
         } else {//RX
            //configure MAC with sourceL2Id/groupL2ID
            rrc_mac_config_req_ue(module_id,0,0, //eNB_index =0
                  (RadioResourceConfigCommonSIB_t *)NULL,
                  (struct PhysicalConfigDedicated *)NULL,
#if defined(Rel10) || defined(Rel14)
                  (SCellToAddMod_r10_t *)NULL,
                  //struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10,
#endif
                  (MeasObjectToAddMod_t **)NULL,
                  (MAC_MainConfig_t *)NULL,
Tien-Thinh Nguyen's avatar
Tien-Thinh Nguyen committed
6132
                  10, //LCID
6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162
                  (struct LogicalChannelConfig *)NULL,
                  (MeasGapConfig_t *)NULL,
                  (TDD_Config_t *)NULL,
                  (MobilityControlInfo_t *)NULL,
                  NULL,
                  NULL,
                  NULL,
                  NULL,
                  NULL,
                  NULL
#if defined(Rel10) || defined(Rel14)
                  ,0,
                  (MBSFN_AreaInfoList_r9_t *)NULL,
                  (PMCH_InfoList_r9_t *)NULL

#endif
#ifdef CBA
                  ,
                  0,
                  0
#endif
#if defined(Rel10) || defined(Rel14)
                  ,CONFIG_ACTION_ADD,
                  &sourceL2Id,
                  NULL
#endif
            );

         }

6163 6164 6165 6166
         LOG_I(RRC,"Send PC5EstablishRsp to ProSe App\n");
         memset(send_buf, 0, BUFSIZE);
         sl_ctrl_msg_send = calloc(1, sizeof(struct sidelink_ctrl_element));
         sl_ctrl_msg_send->type = PC5S_ESTABLISH_RSP;
6167 6168 6169
         sl_ctrl_msg_send->sidelinkPrimitive.pc5s_establish_rsp.slrbid_lcid28 = 10;
         sl_ctrl_msg_send->sidelinkPrimitive.pc5s_establish_rsp.slrbid_lcid29 = 10;
         sl_ctrl_msg_send->sidelinkPrimitive.pc5s_establish_rsp.slrbid_lcid30 = 10;
6170 6171 6172 6173
         memcpy((void *)send_buf, (void *)sl_ctrl_msg_send, sizeof(struct sidelink_ctrl_element));

         prose_addr_len = sizeof(prose_app_addr);
         n = sendto(ctrl_sock_fd, (char *)send_buf, sizeof(struct sidelink_ctrl_element), 0, (struct sockaddr *)&prose_app_addr, prose_addr_len);
6174
//         free(sl_ctrl_msg_send);
6175 6176 6177 6178 6179 6180
         if (n < 0){
            LOG_E(RRC, "ERROR: Failed to send to ProSe App\n");
            exit(EXIT_FAILURE);
         }
         break;

6181

6182
      case PC5_DISCOVERY_MESSAGE:
6183 6184

 #ifdef DEBUG_CTRL_SOCKET
6185
           LOG_I(RRC,"[PC5DiscoveryMessage] Received on socket from ProSe App (msg type: %d)\n",sl_ctrl_msg_recv->type);
6186 6187
 #endif
        //prepare SL_Discovery buffer
6188
         if (UE_rrc_inst) {
6189 6190 6191
           memcpy((void*)&UE_rrc_inst[module_id].SL_Discovery[0].Tx_buffer.Payload[0], (void*)&sl_ctrl_msg_recv->sidelinkPrimitive.pc5_discovery_message.payload[0], PC5_DISCOVERY_PAYLOAD_SIZE);
           UE_rrc_inst[module_id].SL_Discovery[0].Tx_buffer.payload_size = PC5_DISCOVERY_PAYLOAD_SIZE;
           LOG_I(RRC,"[PC5DiscoveryMessage] Copied %d bytes\n",PC5_DISCOVERY_PAYLOAD_SIZE);
6192
         }
6193
         break;
6194 6195 6196 6197 6198 6199 6200 6201 6202
      default:
         break;
      }
   }
   free (sl_ctrl_msg_recv);
   return 0;
}


6203
//-----------------------------------------------------------------------------
6204
int decode_SL_Discovery_Message(
6205 6206 6207 6208 6209 6210 6211 6212 6213
  const protocol_ctxt_t* const ctxt_pP,
  const uint8_t                eNB_index,
  uint8_t*               const Sdu,
  const uint8_t                Sdu_len)
{

   int prose_addr_len;
   char send_buf[BUFSIZE];
   int n;
6214
   struct sidelink_ctrl_element *sl_ctrl_msg_send = NULL;
6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226

   //from the main program, listen for the incoming messages from control socket (ProSe App)
   prose_addr_len = sizeof(prose_app_addr);

   //Store in Rx_buffer
   memcpy((void*)&UE_rrc_inst[ctxt_pP->module_id].SL_Discovery[0].Rx_buffer.Payload[0], (void*)Sdu, Sdu_len);
   UE_rrc_inst[ctxt_pP->module_id].SL_Discovery[0].Rx_buffer.payload_size = Sdu_len;

   memset(send_buf, 0, BUFSIZE);
   //send to ProSeApp
   memcpy((void *)send_buf, (void*)Sdu, Sdu_len);
   prose_addr_len = sizeof(prose_app_addr);
6227

6228 6229 6230
   sl_ctrl_msg_send = calloc(1, sizeof(struct sidelink_ctrl_element));
   sl_ctrl_msg_send->type = PC5_DISCOVERY_MESSAGE;
   // TODO:  Add a check for the SDU size.
William Johnson's avatar
William Johnson committed
6231
   memcpy((void*)&sl_ctrl_msg_send->sidelinkPrimitive.pc5_discovery_message.payload[0], (void*) Sdu,  PC5_DISCOVERY_PAYLOAD_SIZE);
6232 6233 6234 6235 6236 6237 6238

   memcpy((void *)send_buf, (void *)sl_ctrl_msg_send, sizeof(struct sidelink_ctrl_element));
   free(sl_ctrl_msg_send);

   prose_addr_len = sizeof(prose_app_addr);

   n = sendto(ctrl_sock_fd, (char *)send_buf, sizeof(struct sidelink_ctrl_element), 0, (struct sockaddr *)&prose_app_addr, prose_addr_len);
6239
   if (n < 0){
6240 6241
      // TODO:  We should not just exit if the Prose App has not yet attached.  It creates a race condition.
      LOG_I(RRC, "ERROR: Failed to send to ProSe App\n");
6242
      //exit(EXIT_FAILURE);
6243
   }
6244 6245


6246 6247 6248 6249

  return(0);
}

6250
#endif