config.c 24.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/*******************************************************************************

  Eurecom OpenAirInterface
  Copyright(c) 1999 - 2013 Eurecom

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information
  Openair Admin: openair_admin@eurecom.fr
  Openair Tech : openair_tech@eurecom.fr
  Forums       : http://forums.eurecom.fsr/openairinterface
  Address      : Eurecom, 2229, route des crêtes, 06560 Valbonne Sophia Antipolis, France

28
 *******************************************************************************/
29
/*! \file config.c
30 31 32 33 34 35
 * \brief UE and eNB configuration
 * \author Raymond Knopp, Navid Nikaein
 * \date 2013
 * \version 0.1
 * \email: navid.nikaein@eurecom.fr
 * @ingroup _mac
36

37
 */
38

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
#include "COMMON/platform_types.h"
#include "COMMON/platform_constants.h"
#include "SystemInformationBlockType2.h"
//#include "RadioResourceConfigCommonSIB.h"
#include "RadioResourceConfigDedicated.h"
#include "MeasGapConfig.h"
#include "MeasObjectToAddModList.h"
#include "TDD-Config.h"
#include "defs.h"
#include "extern.h"
#include "UTIL/LOG/log.h"
#include "UTIL/LOG/vcd_signal_dumper.h"
#ifdef Rel10
#include "MBSFN-AreaInfoList-r9.h"
#include "MBSFN-AreaInfo-r9.h"
#include "MBSFN-SubframeConfigList.h"
#include "PMCH-InfoList-r9.h"
#endif
57 58

/* sec 5.9, 36.321: MAC Reset Procedure */
59
void ue_mac_reset(module_id_t module_idP,uint8_t eNB_index) {
60

61
  //Resetting Bj
62 63 64
  UE_mac_inst[module_idP].scheduling_info.Bj[0] = 0;
  UE_mac_inst[module_idP].scheduling_info.Bj[1] = 0;
  UE_mac_inst[module_idP].scheduling_info.Bj[2] = 0;
65
  //Stopping all timers
66

67
  //timeAlignmentTimer expires
68

69
  // PHY changes for UE MAC reset
70 71
  mac_xface->phy_reset_ue(module_idP,eNB_index);

72 73
  // notify RRC to relase PUCCH/SRS
  // cancel all pending SRs
74 75 76
  UE_mac_inst[module_idP].scheduling_info.SR_pending=0;
  UE_mac_inst[module_idP].scheduling_info.SR_COUNTER=0;

77
  // stop ongoing RACH procedure
78

79
  // discard explicitly signaled ra_PreambleIndex and ra_RACH_MaskIndex, if any
80 81 82 83 84
  UE_mac_inst[module_idP].RA_prach_resources.ra_PreambleIndex  = 0; // check!
  UE_mac_inst[module_idP].RA_prach_resources.ra_RACH_MaskIndex = 0;

  ue_init_mac(module_idP); //This will hopefully do the rest of the MAC reset procedure

85 86
}

87
int rrc_mac_config_req(module_id_t Mod_id, eNB_flag_t eNB_flagP,uint8_t UE_id,uint8_t eNB_index,
88 89 90 91 92 93 94 95 96
    RadioResourceConfigCommonSIB_t  *radioResourceConfigCommon,
    struct PhysicalConfigDedicated  *physicalConfigDedicated,
    MeasObjectToAddMod_t           **measObj,
    MAC_MainConfig_t                *mac_MainConfig,
    long                             logicalChannelIdentity,
    LogicalChannelConfig_t          *logicalChannelConfig,
    MeasGapConfig_t                 *measGapConfig,
    TDD_Config_t                    *tdd_Config,
    MobilityControlInfo_t           *mobilityControlInfo,
97 98
    uint8_t                              *SIwindowsize,
    uint16_t                             *SIperiod,
99 100 101 102
    ARFCN_ValueEUTRA_t              *ul_CarrierFreq,
    long                            *ul_Bandwidth,
    AdditionalSpectrumEmission_t    *additionalSpectrumEmission,
    struct MBSFN_SubframeConfigList *mbsfn_SubframeConfigList
103
#ifdef Rel10
104
    ,uint8_t                              MBMS_Flag,
105 106
    MBSFN_AreaInfoList_r9_t         *mbsfn_AreaInfoList,
    PMCH_InfoList_r9_t              *pmch_InfoList
107 108
#endif 
#ifdef CBA
109 110
    ,uint8_t                              num_active_cba_groups,
    uint16_t                              cba_rnti
111
#endif
112
) {
113 114 115 116 117

  int i;

  vcd_signal_dumper_dump_function_by_name(VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_MAC_CONFIG, VCD_FUNCTION_IN);

118 119 120 121
  if (eNB_flagP==0) {
      LOG_I(MAC,"[CONFIG][UE %d] Configuring MAC/PHY from eNB %d\n",Mod_id,eNB_index);
      if (tdd_Config != NULL)
        UE_mac_inst[Mod_id].tdd_Config = tdd_Config;
122
  }else {
123 124 125 126 127
      if (physicalConfigDedicated == NULL){
          LOG_I(MAC,"[CONFIG][eNB %d] Configuring MAC/PHY\n",Mod_id);
      } else{
          LOG_I(MAC,"[CONFIG][eNB %d] Configuring MAC/PHY for UE %d (%x)\n",Mod_id,UE_id,find_UE_RNTI(Mod_id,UE_id));
      }
128
  }
129

130
  if ((tdd_Config!=NULL)||(SIwindowsize!=NULL)||(SIperiod!=NULL)){
131 132 133 134
      if (eNB_flagP==1)
        mac_xface->phy_config_sib1_eNB(Mod_id,tdd_Config,*SIwindowsize,*SIperiod);
      else
        mac_xface->phy_config_sib1_ue(Mod_id,eNB_index,tdd_Config,*SIwindowsize,*SIperiod);
135 136
  } 

137
  if (radioResourceConfigCommon!=NULL) {
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
      if (eNB_flagP==1) {
          LOG_I(MAC,"[CONFIG]SIB2/3 Contents (partial)\n");
          LOG_I(MAC,"[CONFIG]pusch_config_common.n_SB = %ld\n",radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.n_SB);
          LOG_I(MAC,"[CONFIG]pusch_config_common.hoppingMode = %ld\n",radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.hoppingMode);
          LOG_I(MAC,"[CONFIG]pusch_config_common.pusch_HoppingOffset = %ld\n",  radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.pusch_HoppingOffset);
          LOG_I(MAC,"[CONFIG]pusch_config_common.enable64QAM = %d\n",radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.enable64QAM);
          LOG_I(MAC,"[CONFIG]pusch_config_common.groupHoppingEnabled = %d\n",radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupHoppingEnabled);
          LOG_I(MAC,"[CONFIG]pusch_config_common.groupAssignmentPUSCH = %ld\n",radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH);
          LOG_I(MAC,"[CONFIG]pusch_config_common.sequenceHoppingEnabled = %d\n",radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled);
          LOG_I(MAC,"[CONFIG]pusch_config_common.cyclicShift  = %ld\n",radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.cyclicShift);
          mac_xface->phy_config_sib2_eNB(Mod_id,radioResourceConfigCommon,ul_CarrierFreq,ul_Bandwidth,additionalSpectrumEmission,mbsfn_SubframeConfigList);
      }
      else {
          UE_mac_inst[Mod_id].radioResourceConfigCommon = radioResourceConfigCommon;
          mac_xface->phy_config_sib2_ue(Mod_id,eNB_index,radioResourceConfigCommon,ul_CarrierFreq,ul_Bandwidth,additionalSpectrumEmission,mbsfn_SubframeConfigList);
      }
154 155 156
  }
  // SRB2_lchan_config->choice.explicitValue.ul_SpecificParameters->logicalChannelGroup
  if (logicalChannelConfig!= NULL) {
157 158 159 160 161 162 163 164 165 166 167
      if (eNB_flagP==0){
          LOG_I(MAC,"[CONFIG][UE %d] Applying RRC logicalChannelConfig from eNB%d\n",Mod_id,eNB_index);
          UE_mac_inst[Mod_id].logicalChannelConfig[logicalChannelIdentity]=logicalChannelConfig;
          UE_mac_inst[Mod_id].scheduling_info.Bj[logicalChannelIdentity]=0; // initilize the bucket for this lcid
          if (logicalChannelConfig->ul_SpecificParameters) {
              UE_mac_inst[Mod_id].scheduling_info.bucket_size[logicalChannelIdentity]=logicalChannelConfig->ul_SpecificParameters->prioritisedBitRate *
                  logicalChannelConfig->ul_SpecificParameters->bucketSizeDuration; // set the max bucket size
              UE_mac_inst[Mod_id].scheduling_info.LCGID[logicalChannelIdentity]=*logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup;
              LOG_D(MAC,"[CONFIG][UE %d] LCID %d is attached to the LCGID %d\n",Mod_id,logicalChannelIdentity,*logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup);
          } else {
              LOG_E(MAC,"[CONFIG][UE %d] LCID %d NULL ul_SpecificParameters\n",Mod_id,logicalChannelIdentity);
gauthier's avatar
gauthier committed
168
              mac_xface->macphy_exit("NULL ul_SpecificParameters");
169
          }
170 171 172 173
      }
  }

  if (mac_MainConfig != NULL){
174 175 176 177 178 179 180
      if (eNB_flagP==0){
          LOG_I(MAC,"[CONFIG][UE%d] Applying RRC macMainConfig from eNB%d\n",Mod_id,eNB_index);
          UE_mac_inst[Mod_id].macConfig=mac_MainConfig;
          UE_mac_inst[Mod_id].measGapConfig=measGapConfig;
          if (mac_MainConfig->ul_SCH_Config) {

              if (mac_MainConfig->ul_SCH_Config->periodicBSR_Timer)
181
                UE_mac_inst[Mod_id].scheduling_info.periodicBSR_Timer = (uint16_t) *mac_MainConfig->ul_SCH_Config->periodicBSR_Timer;
182
              else
183
                UE_mac_inst[Mod_id].scheduling_info.periodicBSR_Timer = (uint16_t) MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_infinity;
184 185

              if (mac_MainConfig->ul_SCH_Config->maxHARQ_Tx)
186
                UE_mac_inst[Mod_id].scheduling_info.maxHARQ_Tx     = (uint16_t) *mac_MainConfig->ul_SCH_Config->maxHARQ_Tx;
187
              else
188
                UE_mac_inst[Mod_id].scheduling_info.maxHARQ_Tx     = (uint16_t) MAC_MainConfig__ul_SCH_Config__maxHARQ_Tx_n5;
189
              if (mac_MainConfig->ul_SCH_Config->retxBSR_Timer)
190
                UE_mac_inst[Mod_id].scheduling_info.retxBSR_Timer     = (uint16_t) mac_MainConfig->ul_SCH_Config->retxBSR_Timer;
191
              else
192
                UE_mac_inst[Mod_id].scheduling_info.retxBSR_Timer     = (uint16_t)MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf2560;
193
          }
194
#ifdef Rel10   
195
          if (mac_MainConfig->sr_ProhibitTimer_r9)
196
            UE_mac_inst[Mod_id].scheduling_info.sr_ProhibitTimer  = (uint16_t) *mac_MainConfig->sr_ProhibitTimer_r9;
197
          else
198
            UE_mac_inst[Mod_id].scheduling_info.sr_ProhibitTimer  = (uint16_t) 0;
199
#endif
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
          UE_mac_inst[Mod_id].scheduling_info.periodicBSR_SF  = get_sf_periodicBSRTimer(UE_mac_inst[Mod_id].scheduling_info.periodicBSR_Timer);
          UE_mac_inst[Mod_id].scheduling_info.retxBSR_SF     = get_sf_retxBSRTimer(UE_mac_inst[Mod_id].scheduling_info.retxBSR_Timer);

          UE_mac_inst[Mod_id].scheduling_info.drx_config     = mac_MainConfig->drx_Config;
          UE_mac_inst[Mod_id].scheduling_info.phr_config     = mac_MainConfig->phr_Config;
          if (mac_MainConfig->phr_Config){
              UE_mac_inst[Mod_id].PHR_state = mac_MainConfig->phr_Config->present;
              UE_mac_inst[Mod_id].PHR_reconfigured = 1;
              UE_mac_inst[Mod_id].scheduling_info.periodicPHR_Timer = mac_MainConfig->phr_Config->choice.setup.periodicPHR_Timer;
              UE_mac_inst[Mod_id].scheduling_info.prohibitPHR_Timer = mac_MainConfig->phr_Config->choice.setup.prohibitPHR_Timer;
              UE_mac_inst[Mod_id].scheduling_info.PathlossChange = mac_MainConfig->phr_Config->choice.setup.dl_PathlossChange;
          } else {
              UE_mac_inst[Mod_id].PHR_reconfigured = 0;
              UE_mac_inst[Mod_id].PHR_state = MAC_MainConfig__phr_Config_PR_setup;
              UE_mac_inst[Mod_id].scheduling_info.periodicPHR_Timer = MAC_MainConfig__phr_Config__setup__periodicPHR_Timer_sf20;
              UE_mac_inst[Mod_id].scheduling_info.prohibitPHR_Timer = MAC_MainConfig__phr_Config__setup__prohibitPHR_Timer_sf20;
              UE_mac_inst[Mod_id].scheduling_info.PathlossChange = MAC_MainConfig__phr_Config__setup__dl_PathlossChange_dB1;
          }
          UE_mac_inst[Mod_id].scheduling_info.periodicPHR_SF =  get_sf_perioidicPHR_Timer(UE_mac_inst[Mod_id].scheduling_info.periodicPHR_Timer);
          UE_mac_inst[Mod_id].scheduling_info.prohibitPHR_SF =  get_sf_prohibitPHR_Timer(UE_mac_inst[Mod_id].scheduling_info.prohibitPHR_Timer);
          UE_mac_inst[Mod_id].scheduling_info.PathlossChange_db =  get_db_dl_PathlossChange(UE_mac_inst[Mod_id].scheduling_info.PathlossChange);
          LOG_D(MAC,"[UE %d] config PHR (%d): periodic %d (SF) prohibit %d (SF)  pathlosschange %d (db) \n",
              Mod_id,mac_MainConfig->phr_Config->present,
              UE_mac_inst[Mod_id].scheduling_info.periodicPHR_SF,
              UE_mac_inst[Mod_id].scheduling_info.prohibitPHR_SF,
              UE_mac_inst[Mod_id].scheduling_info.PathlossChange_db);
      }
227 228 229
  }

  if (physicalConfigDedicated != NULL) {
230 231 232 233 234 235
      if (eNB_flagP==1){
          mac_xface->phy_config_dedicated_eNB(Mod_id,find_UE_RNTI(Mod_id,UE_id),physicalConfigDedicated);
      }else{
          mac_xface->phy_config_dedicated_ue(Mod_id,eNB_index,physicalConfigDedicated);
          UE_mac_inst[Mod_id].physicalConfigDedicated=physicalConfigDedicated; // for SR proc
      }
236 237
  }

238 239 240 241 242 243 244 245 246 247 248 249
  if (eNB_flagP == 0) {
      if (measObj!= NULL) {
          if (measObj[0]!= NULL){
              UE_mac_inst[Mod_id].n_adj_cells = measObj[0]->measObject.choice.measObjectEUTRA.cellsToAddModList->list.count;
              LOG_I(MAC,"Number of adjacent cells %d\n",UE_mac_inst[Mod_id].n_adj_cells);
              for (i=0;i<UE_mac_inst[Mod_id].n_adj_cells;i++) {
                  UE_mac_inst[Mod_id].adj_cell_id[i] = measObj[0]->measObject.choice.measObjectEUTRA.cellsToAddModList->list.array[i]->physCellId;
                  LOG_I(MAC,"Cell %d : Nid_cell %d\n",i,UE_mac_inst[Mod_id].adj_cell_id[i]);
              }
              mac_xface->phy_config_meas_ue(Mod_id,eNB_index,UE_mac_inst[Mod_id].n_adj_cells,UE_mac_inst[Mod_id].adj_cell_id);
          }
          /*
250 251 252 253 254 255 256
    if (quantityConfig != NULL) {
    	if (quantityConfig[0] != NULL) {
    		UE_mac_inst[Mod_id].quantityConfig = quantityConfig[0];
    		LOG_I(MAC,"UE %d configured filterCoeff.",UE_mac_inst[Mod_id].crnti);
    		mac_xface->phy_config_meas_ue
    	}
    }
257
           */
258
      }
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
  }
  if (eNB_flagP==0) {
      if(mobilityControlInfo != NULL) {

          LOG_D(MAC,"[UE%d] MAC Reset procedure triggered by RRC eNB %d \n",Mod_id,eNB_index);
          ue_mac_reset(Mod_id,eNB_index);

          if(mobilityControlInfo->radioResourceConfigCommon.rach_ConfigCommon) {
              memcpy((void *)&UE_mac_inst[Mod_id].radioResourceConfigCommon->rach_ConfigCommon,
                  (void *)mobilityControlInfo->radioResourceConfigCommon.rach_ConfigCommon,
                  sizeof(RACH_ConfigCommon_t));
          }

          memcpy((void *)&UE_mac_inst[Mod_id].radioResourceConfigCommon->prach_Config.prach_ConfigInfo,
              (void *)mobilityControlInfo->radioResourceConfigCommon.prach_Config.prach_ConfigInfo,
              sizeof(PRACH_ConfigInfo_t));
          UE_mac_inst[Mod_id].radioResourceConfigCommon->prach_Config.rootSequenceIndex = mobilityControlInfo->radioResourceConfigCommon.prach_Config.rootSequenceIndex;

          if(mobilityControlInfo->radioResourceConfigCommon.pdsch_ConfigCommon) {
              memcpy((void *)&UE_mac_inst[Mod_id].radioResourceConfigCommon->pdsch_ConfigCommon,
                  (void *)mobilityControlInfo->radioResourceConfigCommon.pdsch_ConfigCommon,
                  sizeof(PDSCH_ConfigCommon_t));
          }
          // not a pointer: mobilityControlInfo->radioResourceConfigCommon.pusch_ConfigCommon
          memcpy((void *)&UE_mac_inst[Mod_id].radioResourceConfigCommon->pusch_ConfigCommon,
              (void *)&mobilityControlInfo->radioResourceConfigCommon.pusch_ConfigCommon,
              sizeof(PUSCH_ConfigCommon_t));

          if(mobilityControlInfo->radioResourceConfigCommon.phich_Config) {
              /* memcpy((void *)&UE_mac_inst[Mod_id].radioResourceConfigCommon->phich_Config,
289 290
	   (void *)mobilityControlInfo->radioResourceConfigCommon.phich_Config,
	   sizeof(PHICH_Config_t)); */
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
          }
          if(mobilityControlInfo->radioResourceConfigCommon.pucch_ConfigCommon) {
              memcpy((void *)&UE_mac_inst[Mod_id].radioResourceConfigCommon->pucch_ConfigCommon,
                  (void *)mobilityControlInfo->radioResourceConfigCommon.pucch_ConfigCommon,
                  sizeof(PUCCH_ConfigCommon_t));
          }
          if(mobilityControlInfo->radioResourceConfigCommon.soundingRS_UL_ConfigCommon) {
              memcpy((void *)&UE_mac_inst[Mod_id].radioResourceConfigCommon->soundingRS_UL_ConfigCommon,
                  (void *)mobilityControlInfo->radioResourceConfigCommon.soundingRS_UL_ConfigCommon,
                  sizeof(SoundingRS_UL_ConfigCommon_t));
          }
          if(mobilityControlInfo->radioResourceConfigCommon.uplinkPowerControlCommon) {
              memcpy((void *)&UE_mac_inst[Mod_id].radioResourceConfigCommon->uplinkPowerControlCommon,
                  (void *)mobilityControlInfo->radioResourceConfigCommon.uplinkPowerControlCommon,
                  sizeof(UplinkPowerControlCommon_t));
          }
          //configure antennaInfoCommon somewhere here..
          if(mobilityControlInfo->radioResourceConfigCommon.p_Max) {
              //to be configured
          }
          if(mobilityControlInfo->radioResourceConfigCommon.tdd_Config) {
              UE_mac_inst[Mod_id].tdd_Config = mobilityControlInfo->radioResourceConfigCommon.tdd_Config;
          }
          if(mobilityControlInfo->radioResourceConfigCommon.ul_CyclicPrefixLength) {
              memcpy((void *)&UE_mac_inst[Mod_id].radioResourceConfigCommon->ul_CyclicPrefixLength,
                  (void *)mobilityControlInfo->radioResourceConfigCommon.ul_CyclicPrefixLength,
                  sizeof(UL_CyclicPrefixLength_t));
          }
          // store the previous rnti in case of failure, and set thenew rnti
          UE_mac_inst[Mod_id].crnti_before_ho = UE_mac_inst[Mod_id].crnti;
          UE_mac_inst[Mod_id].crnti = ((mobilityControlInfo->newUE_Identity.buf[0])|(mobilityControlInfo->newUE_Identity.buf[1]<<8));
          LOG_I(MAC,"[UE %d] Received new identity %x from %d\n", Mod_id, UE_mac_inst[Mod_id].crnti, eNB_index);
          UE_mac_inst[Mod_id].rach_ConfigDedicated = malloc(sizeof(*mobilityControlInfo->rach_ConfigDedicated));
          if (mobilityControlInfo->rach_ConfigDedicated){
              memcpy((void*)UE_mac_inst[Mod_id].rach_ConfigDedicated,
                  (void*)mobilityControlInfo->rach_ConfigDedicated,
                  sizeof(*mobilityControlInfo->rach_ConfigDedicated));
          }
          mac_xface->phy_config_afterHO_ue(Mod_id,eNB_index,mobilityControlInfo,0);
330 331
      }
  }
332

333
  if (mbsfn_SubframeConfigList != NULL) {
334 335 336 337 338 339 340 341
      if (eNB_flagP == 1) {
          LOG_I(MAC,"[eNB %d][CONFIG] Received %d subframe allocation pattern for MBSFN\n", Mod_id, mbsfn_SubframeConfigList->list.count);
          eNB_mac_inst[Mod_id].num_sf_allocation_pattern= mbsfn_SubframeConfigList->list.count;
          for (i=0; i<mbsfn_SubframeConfigList->list.count; i++) {
              eNB_mac_inst[Mod_id].mbsfn_SubframeConfig[i] = mbsfn_SubframeConfigList->list.array[i];
              LOG_I(MAC, "[eNB %d][CONFIG] MBSFN_SubframeConfig[%d] pattern is  %x\n", Mod_id, i,
                  eNB_mac_inst[Mod_id].mbsfn_SubframeConfig[i]->subframeAllocation.choice.oneFrame.buf[0]);
          }
342
#ifdef Rel10
343
          eNB_mac_inst[Mod_id].MBMS_flag = MBMS_Flag;
344 345
#endif
      }
346 347 348 349 350 351 352 353 354 355
      else { // UE
          LOG_I(MAC,"[UE %d][CONFIG] Received %d subframe allocation pattern for MBSFN\n", Mod_id, mbsfn_SubframeConfigList->list.count);
          UE_mac_inst[Mod_id].num_sf_allocation_pattern= mbsfn_SubframeConfigList->list.count;
          for (i=0; i<mbsfn_SubframeConfigList->list.count; i++) {
              LOG_I(MAC, "[UE %d] Configuring MBSFN_SubframeConfig %d from received SIB2 \n", Mod_id, i);
              UE_mac_inst[Mod_id].mbsfn_SubframeConfig[i] = mbsfn_SubframeConfigList->list.array[i];
              //	LOG_I("[UE %d] MBSFN_SubframeConfig[%d] pattern is  %ld\n", Mod_id,
              //    UE_mac_inst[Mod_id].mbsfn_SubframeConfig[i]->subframeAllocation.choice.oneFrame.buf[0]);
          }
      }
356 357 358 359
  }

#ifdef Rel10
  if (mbsfn_AreaInfoList != NULL) {
360 361 362 363 364 365 366 367 368 369
      if (eNB_flagP == 1) {
          // One eNB could be part of multiple mbsfn syc area, this could change over time so reset each time
          LOG_I(MAC,"[eNB %d][CONFIG] Received %d MBSFN Area Info\n", Mod_id, mbsfn_AreaInfoList->list.count);
          eNB_mac_inst[Mod_id].num_active_mbsfn_area = mbsfn_AreaInfoList->list.count;
          for (i =0; i< mbsfn_AreaInfoList->list.count; i++) {
              eNB_mac_inst[Mod_id].mbsfn_AreaInfo[i] = mbsfn_AreaInfoList->list.array[i];
              LOG_I(MAC,"[eNB %d][CONFIG] MBSFN_AreaInfo[%d]: MCCH Repetition Period = %ld\n", Mod_id,i,
                  eNB_mac_inst[Mod_id].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_RepetitionPeriod_r9);
              mac_xface->phy_config_sib13_eNB(Mod_id,i,eNB_mac_inst[Mod_id].mbsfn_AreaInfo[i]->mbsfn_AreaId_r9);
          }
370
      }
371 372 373 374 375 376 377 378 379
      else {  // UE
          LOG_I(MAC,"[UE %d][CONFIG] Received %d MBSFN Area Info\n", Mod_id, mbsfn_AreaInfoList->list.count);
          UE_mac_inst[Mod_id].num_active_mbsfn_area = mbsfn_AreaInfoList->list.count;
          for (i =0; i< mbsfn_AreaInfoList->list.count; i++) {
              UE_mac_inst[Mod_id].mbsfn_AreaInfo[i] = mbsfn_AreaInfoList->list.array[i];
              LOG_I(MAC,"[UE %d] MBSFN_AreaInfo[%d]: MCCH Repetition Period = %ld\n",Mod_id, i,
                  UE_mac_inst[Mod_id].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_RepetitionPeriod_r9);
              mac_xface->phy_config_sib13_ue(Mod_id,eNB_index,i,UE_mac_inst[Mod_id].mbsfn_AreaInfo[i]->mbsfn_AreaId_r9);
          }
380 381 382
      }
  }

383

384
  if (pmch_InfoList != NULL) {
385

386
      //    LOG_I(MAC,"DUY: lcid when entering rrc_mac config_req is %02d\n",(pmch_InfoList->list.array[0]->mbms_SessionInfoList_r9.list.array[0]->logicalChannelIdentity_r9));
387

388
      if (eNB_flagP == 1) {
389

390
          LOG_I(MAC, "[CONFIG] Number of PMCH in this MBSFN Area %d\n", pmch_InfoList->list.count);
391

392 393
          for (i =0; i< pmch_InfoList->list.count; i++) {
              eNB_mac_inst[Mod_id].pmch_Config[i] = &pmch_InfoList->list.array[i]->pmch_Config_r9;
394

395 396 397 398 399 400
              LOG_I(MAC, "[CONFIG] PMCH[%d]: This PMCH stop at subframe  %ldth\n", i,
                  eNB_mac_inst[Mod_id].pmch_Config[i]->sf_AllocEnd_r9);
              LOG_I(MAC, "[CONFIG] PMCH[%d]: mch_Scheduling_Period = %ld\n", i,
                  eNB_mac_inst[Mod_id].pmch_Config[i]->mch_SchedulingPeriod_r9);
              LOG_I(MAC, "[CONFIG] PMCH[%d]: dataMCS = %ld\n", i,
                  eNB_mac_inst[Mod_id].pmch_Config[i]->dataMCS_r9);
401

402 403 404 405
              // MBMS session info list in each MCH
              eNB_mac_inst[Mod_id].mbms_SessionList[i] = &pmch_InfoList->list.array[i]->mbms_SessionInfoList_r9;
              LOG_I(MAC, "PMCH[%d] Number of session (MTCH) is: %d\n",i, eNB_mac_inst[Mod_id].mbms_SessionList[i]->list.count);
          }
406
      }
407 408 409 410 411 412 413 414
      else { // UE
          LOG_I(MAC, "[UE %d] Configuring PMCH_config from MCCH MESSAGE \n",Mod_id);
          for (i =0; i< pmch_InfoList->list.count; i++) {
              UE_mac_inst[Mod_id].pmch_Config[i] = &pmch_InfoList->list.array[i]->pmch_Config_r9;
              LOG_I(MAC, "[UE %d] PMCH[%d]: MCH_Scheduling_Period = %ld\n", Mod_id, i,
                  UE_mac_inst[Mod_id].pmch_Config[i]->mch_SchedulingPeriod_r9);
          }
          UE_mac_inst[Mod_id].mcch_status = 1;
415 416
      }
  }
417

418 419
#endif
#ifdef CBA
420 421 422 423 424 425 426
  if (eNB_flagP == 0){
      if (cba_rnti) {
          UE_mac_inst[Mod_id].cba_rnti[num_active_cba_groups-1] = cba_rnti;
          LOG_D(MAC,"[UE %d] configure CBA group %d RNTI %x for eNB %d (total active cba group %d)\n",
              Mod_id,Mod_id%num_active_cba_groups, cba_rnti,eNB_index,num_active_cba_groups);
          mac_xface->phy_config_cba_rnti(Mod_id,eNB_flagP,eNB_index,cba_rnti,num_active_cba_groups-1, num_active_cba_groups);
      }
427
  }else {
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
      if (cba_rnti) {
          LOG_D(MAC,"[eNB %d] configure CBA RNTI for UE  %d (total active cba groups %d)\n",
              Mod_id, UE_id, num_active_cba_groups);
          eNB_mac_inst[Mod_id].num_active_cba_groups=num_active_cba_groups;
          for (i=0; i < num_active_cba_groups; i ++){
              if (eNB_mac_inst[Mod_id].cba_rnti[i] != cba_rnti + i)
                eNB_mac_inst[Mod_id].cba_rnti[i] = cba_rnti + i;
              //only configure UE ids up to num_active_cba_groups
              //we use them as candidates for the transmission of dci format0)
              if (UE_id%num_active_cba_groups == i){
                  mac_xface->phy_config_cba_rnti(Mod_id,eNB_flagP,UE_id,cba_rnti + i,i,num_active_cba_groups );
                  LOG_D(MAC,"[eNB %d] configure CBA groups %d with RNTI %x for UE  %d (total active cba groups %d)\n",
                      Mod_id, i, eNB_mac_inst[Mod_id].cba_rnti[i],UE_id, num_active_cba_groups);
              }
          }
443 444 445 446 447 448 449 450
      }
  }

#endif
  vcd_signal_dumper_dump_function_by_name(VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_MAC_CONFIG, VCD_FUNCTION_OUT);

  return(0);
}