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

/*! \file ue_procedures.c
23
 * \brief procedures related to UE
24 25 26
 * \author  Navid Nikaein and Raymond Knopp
 * \date 2010 - 2014
 * \version 1
27 28
 * \email: navid.nikaein@eurecom.fr
 * @ingroup _mac
29

30
 */
31

32 33 34 35
#ifdef EXMIMO
#include <pthread.h>
#endif

36 37
#include "extern.h"
#include "defs.h"
38
#include "proto.h"
39
#ifdef PHY_EMUL
Cedric Roux's avatar
Cedric Roux committed
40
# include "SIMULATION/PHY_EMULATION/impl_defs.h"
41
#else
Cedric Roux's avatar
Cedric Roux committed
42 43
# include "SCHED/defs.h"
# include "PHY/impl_defs_top.h"
44 45 46 47
#endif
#include "PHY_INTERFACE/defs.h"
#include "PHY_INTERFACE/extern.h"
#include "COMMON/mac_rrc_primitives.h"
Cedric Roux's avatar
Cedric Roux committed
48 49

#include "RRC/L2_INTERFACE/openair_rrc_L2_interface.h"
50 51 52
#include "RRC/LITE/extern.h"
#include "UTIL/LOG/log.h"
#include "UTIL/LOG/vcd_signal_dumper.h"
Cedric Roux's avatar
Cedric Roux committed
53
#include "UTIL/OPT/opt.h"
54 55
#include "OCG.h"
#include "OCG_extern.h"
Cedric Roux's avatar
Cedric Roux committed
56

57
#ifdef PHY_EMUL
Cedric Roux's avatar
Cedric Roux committed
58
# include "SIMULATION/simulation_defs.h"
59
#endif
60
#include "pdcp.h"
61

62 63 64 65
#if defined(ENABLE_ITTI)
# include "intertask_interface.h"
#endif

66 67
#include "assertions.h"

68 69
#include "SIMULATION/TOOLS/defs.h" // for taus

70
#define DEBUG_HEADER_PARSING 1
71
#define ENABLE_MAC_PAYLOAD_DEBUG 1
72 73 74 75 76

/*
#ifndef USER_MODE
#define msg debug_msg
#endif
77
 */
78
mapping BSR_names[] = {
79 80 81 82 83 84
  {"NONE", 0},
  {"SHORT BSR", 1},
  {"TRUNCATED BSR", 2},
  {"LONG BSR", 3},
  {"PADDING BSR", 4},
  {NULL, -1}
85 86 87
};


88 89
void ue_init_mac(module_id_t module_idP)
{
90 91
  int i;
  // default values as deined in 36.331 sec 9.2.2
92 93
  LOG_I(MAC,"[UE%d] Applying default macMainConfig\n",module_idP);
  //UE_mac_inst[module_idP].scheduling_info.macConfig=NULL;
hbilel's avatar
hbilel committed
94
  UE_mac_inst[module_idP].scheduling_info.retxBSR_Timer= MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf10240;
95 96 97 98 99 100 101 102 103 104
  UE_mac_inst[module_idP].scheduling_info.periodicBSR_Timer=MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_infinity;
  UE_mac_inst[module_idP].scheduling_info.periodicPHR_Timer = MAC_MainConfig__phr_Config__setup__periodicPHR_Timer_sf20;
  UE_mac_inst[module_idP].scheduling_info.prohibitPHR_Timer = MAC_MainConfig__phr_Config__setup__prohibitPHR_Timer_sf20;
  UE_mac_inst[module_idP].scheduling_info.PathlossChange_db = MAC_MainConfig__phr_Config__setup__dl_PathlossChange_dB1;
  UE_mac_inst[module_idP].PHR_state = MAC_MainConfig__phr_Config_PR_setup;
  UE_mac_inst[module_idP].scheduling_info.SR_COUNTER=0;
  UE_mac_inst[module_idP].scheduling_info.sr_ProhibitTimer=0;
  UE_mac_inst[module_idP].scheduling_info.sr_ProhibitTimer_Running=0;
  UE_mac_inst[module_idP].scheduling_info.maxHARQ_Tx=MAC_MainConfig__ul_SCH_Config__maxHARQ_Tx_n5;
  UE_mac_inst[module_idP].scheduling_info.ttiBundling=0;
fnabet's avatar
fnabet committed
105 106
  UE_mac_inst[module_idP].scheduling_info.extendedBSR_Sizes_r10=0;
  UE_mac_inst[module_idP].scheduling_info.extendedPHR_r10=0;
107 108
  UE_mac_inst[module_idP].scheduling_info.drx_config=NULL;
  UE_mac_inst[module_idP].scheduling_info.phr_config=NULL;
calvin wang's avatar
calvin wang committed
109
  // set init value 0xFFFF, make sure periodic timer and retx time counters are NOT active, after bsr transmission set the value configured by the NW.
hbilel's avatar
hbilel committed
110 111
  UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF  =  MAC_UE_BSR_TIMER_NOT_RUNNING;
  UE_mac_inst[module_idP].scheduling_info.retxBSR_SF     =  MAC_UE_BSR_TIMER_NOT_RUNNING;
112
  UE_mac_inst[module_idP].BSR_reporting_active = BSR_TRIGGER_NONE;
calvin wang's avatar
calvin wang committed
113
  
114 115 116
  UE_mac_inst[module_idP].scheduling_info.periodicPHR_SF =  get_sf_perioidicPHR_Timer(UE_mac_inst[module_idP].scheduling_info.periodicPHR_Timer);
  UE_mac_inst[module_idP].scheduling_info.prohibitPHR_SF =  get_sf_prohibitPHR_Timer(UE_mac_inst[module_idP].scheduling_info.prohibitPHR_Timer);
  UE_mac_inst[module_idP].scheduling_info.PathlossChange_db =  get_db_dl_PathlossChange(UE_mac_inst[module_idP].scheduling_info.PathlossChange);
fnabet's avatar
fnabet committed
117
  UE_mac_inst[module_idP].PHR_reporting_active = 0;
118 119

  for (i=0; i < MAX_NUM_LCID; i++) {
Raymond Knopp's avatar
 
Raymond Knopp committed
120 121
    LOG_D(MAC,"[UE%d] Applying default logical channel config for LCGID %d\n",module_idP,i);
    UE_mac_inst[module_idP].scheduling_info.Bj[i]=-1;
122 123
    UE_mac_inst[module_idP].scheduling_info.bucket_size[i]=-1;

124
    if (i < DTCH) { // initilize all control channels lcgid to 0
125
      UE_mac_inst[module_idP].scheduling_info.LCGID[i]=0;
126
    } else { // initialize all the data channels lcgid to 1
127
      UE_mac_inst[module_idP].scheduling_info.LCGID[i]=1;
128
    }
129

fnabet's avatar
fnabet committed
130
    UE_mac_inst[module_idP].scheduling_info.LCID_status[i]=LCID_EMPTY;
hbilel's avatar
hbilel committed
131
    UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[i] = 0;
132
  }
133

134
#ifdef CBA
135

136
  for (i=0; i <NUM_MAX_CBA_GROUP; i++) {
137
    UE_mac_inst[module_idP].cba_last_access[i]= round(uniform_rngen(1,30));
138
  }
139 140

#endif
141 142
}

Raymond Knopp's avatar
 
Raymond Knopp committed
143

144
unsigned char *parse_header(unsigned char *mac_header,
145 146 147 148 149 150 151
                            unsigned char *num_ce,
                            unsigned char *num_sdu,
                            unsigned char *rx_ces,
                            unsigned char *rx_lcids,
                            unsigned short *rx_lengths,
                            unsigned short tb_length)
{
152

fnabet's avatar
fnabet committed
153
  unsigned char not_done=1,num_ces=0,num_cont_res = 0,num_padding = 0,num_sdus=0,lcid, num_sdu_cnt;
154 155 156 157 158
  unsigned char *mac_header_ptr = mac_header;
  unsigned short length,ce_len=0;

  while (not_done==1) {

159 160 161 162 163 164 165 166 167 168 169 170 171
    if (((SCH_SUBHEADER_FIXED *)mac_header_ptr)->E == 0) {
      //      printf("E=0\n");
      not_done = 0;
    }

    lcid = ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->LCID;

    if (lcid < UE_CONT_RES) {
      //printf("[MAC][UE] header %x.%x.%x\n",mac_header_ptr[0],mac_header_ptr[1],mac_header_ptr[2]);
      if (not_done==0) {// last MAC SDU, length is implicit
        mac_header_ptr++;
        length = tb_length-(mac_header_ptr-mac_header)-ce_len;

172
        for (num_sdu_cnt=0; num_sdu_cnt < num_sdus ; num_sdu_cnt++) {
173
          length -= rx_lengths[num_sdu_cnt];
174
        }
175 176 177 178
      } else {
        if (((SCH_SUBHEADER_LONG *)mac_header_ptr)->F == 1) {
          length = ((((SCH_SUBHEADER_LONG *)mac_header_ptr)->L_MSB & 0x7f ) << 8 ) | (((SCH_SUBHEADER_LONG *)mac_header_ptr)->L_LSB & 0xff);
          mac_header_ptr += 3;
179
#ifdef DEBUG_HEADER_PARSING
180
          LOG_D(MAC,"[UE] parse long sdu, size %x \n",length);
181
#endif
182

183 184 185 186 187 188
        }  else { //if (((SCH_SUBHEADER_SHORT *)mac_header_ptr)->F == 0) {
          length = ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->L;
          mac_header_ptr += 2;
        }
      }

189
#ifdef DEBUG_HEADER_PARSING
190 191
      LOG_D(MAC,"[UE] sdu %d lcid %d length %d (offset now %d)\n",
            num_sdus,lcid,length,mac_header_ptr-mac_header);
192
#endif
193 194 195 196 197
      rx_lcids[num_sdus] = lcid;
      rx_lengths[num_sdus] = length;
      num_sdus++;
    } else { // This is a control element subheader
      if (lcid == SHORT_PADDING) {
fnabet's avatar
fnabet committed
198
    	num_padding ++;
199 200 201 202 203 204
        mac_header_ptr++;
      } else {
        rx_ces[num_ces] = lcid;
        num_ces++;
        mac_header_ptr ++;

205
        if (lcid==TIMING_ADV_CMD) {
206
          ce_len++;
207
        } else if (lcid==UE_CONT_RES) {
fnabet's avatar
fnabet committed
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224

        	// FNA: check MAC Header is one of thoses defined in Annex B of 36.321
        	// Check there is only 1 Contention Resolution
        	if (num_cont_res) {
        		LOG_W(MAC,"[UE] Msg4 Wrong received format: More than 1 Contention Resolution\n");
        		// exit parsing
        		return NULL;

        	}

        	// UE_CONT_RES shall never be the last subheader unless this is the only MAC subheader
        	if ((not_done == 0) && ((num_sdus) || (num_ces > 1) || (num_padding))) {
        		LOG_W(MAC,"[UE] Msg4 Wrong received format: Contention Resolution after num_ces=%d num_sdus=%d num_padding=%d\n",num_ces,num_sdus,num_padding);
        		// exit parsing
        		return NULL;
        	}
          num_cont_res ++;
225
          ce_len+=6;
226
        }
227
      }
228

229
#ifdef DEBUG_HEADER_PARSING
230
      LOG_D(MAC,"[UE] ce %d lcid %d (offset now %d)\n",num_ces,lcid,mac_header_ptr-mac_header);
231
#endif
232
    }
233
  }
234

235 236 237 238 239 240
  *num_ce = num_ces;
  *num_sdu = num_sdus;

  return(mac_header_ptr);
}

241 242
uint32_t ue_get_SR(module_id_t module_idP,int CC_id,frame_t frameP,uint8_t eNB_id,uint16_t rnti, sub_frame_t subframe)
{
243 244 245

  // no UL-SCH resources available for this tti && UE has a valid PUCCH resources for SR configuration for this tti
  //  int MGL=6;// measurement gap length in ms
246 247 248
  int MGRP       = 0; // measurement gap repetition period in ms
  int gapOffset  = -1;
  int T          = 0;
249

250
  DevCheck(module_idP < (int)NB_UE_INST, module_idP, NB_UE_INST, 0);
251

Raymond Knopp's avatar
 
Raymond Knopp committed
252 253 254
  if (CC_id>0) {
    LOG_E(MAC,"Transmission on secondary CCs is not supported yet\n");
    mac_xface->macphy_exit("MAC FATAL  CC_id>0");
255
    return 0;
Raymond Knopp's avatar
 
Raymond Knopp committed
256 257
  }

258
  // determin the measurement gap
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
  if (UE_mac_inst[module_idP].measGapConfig !=NULL) {
    if (UE_mac_inst[module_idP].measGapConfig->choice.setup.gapOffset.present == MeasGapConfig__setup__gapOffset_PR_gp0) {
      MGRP= 40;
      gapOffset= UE_mac_inst[module_idP].measGapConfig->choice.setup.gapOffset.choice.gp0;
    } else if (UE_mac_inst[module_idP].measGapConfig->choice.setup.gapOffset.present == MeasGapConfig__setup__gapOffset_PR_gp1) {
      MGRP= 80;
      gapOffset= UE_mac_inst[module_idP].measGapConfig->choice.setup.gapOffset.choice.gp1;
    } else {
      LOG_W(MAC, "Measurement GAP offset is unknown\n");
    }

    T=MGRP/10;
    DevAssert( T != 0 );

    //check the measurement gap and sr prohibit timer
    if ((subframe ==  gapOffset %10) && ((frameP %T) == (floor(gapOffset/10)))
        && (UE_mac_inst[module_idP].scheduling_info.sr_ProhibitTimer_Running ==0)) {
      UE_mac_inst[module_idP].scheduling_info.SR_pending=1;
      return(0);
    }
279
  }
280 281

  if ((UE_mac_inst[module_idP].physicalConfigDedicated != NULL) &&
282
      (UE_mac_inst[module_idP].scheduling_info.SR_pending==1) &&
283
      (UE_mac_inst[module_idP].scheduling_info.SR_COUNTER <
284 285
       (1<<(2+UE_mac_inst[module_idP].physicalConfigDedicated->schedulingRequestConfig->choice.setup.dsr_TransMax)))
     ) {
286
    LOG_D(MAC,"[UE %d][SR %x] Frame %d subframe %d PHY asks for SR (SR_COUNTER/dsr_TransMax %d/%d), SR_pending %d\n",
287
          module_idP,rnti,frameP,subframe,
288 289 290 291
          UE_mac_inst[module_idP].scheduling_info.SR_COUNTER,
          (1<<(2+UE_mac_inst[module_idP].physicalConfigDedicated->schedulingRequestConfig->choice.setup.dsr_TransMax)),
          UE_mac_inst[module_idP].scheduling_info.SR_pending);

292
    UE_mac_inst[module_idP].scheduling_info.SR_COUNTER++;
293

294 295 296 297
    // start the sr-prohibittimer : rel 9 and above
    if (UE_mac_inst[module_idP].scheduling_info.sr_ProhibitTimer > 0) { // timer configured
      UE_mac_inst[module_idP].scheduling_info.sr_ProhibitTimer--;
      UE_mac_inst[module_idP].scheduling_info.sr_ProhibitTimer_Running=1;
298
    } else {
299
      UE_mac_inst[module_idP].scheduling_info.sr_ProhibitTimer_Running=0;
300
    }
301 302 303 304 305 306 307 308 309 310 311 312 313

    LOG_D(MAC,"[UE %d][SR %x] Frame %d subframe %d send SR indication (SR_COUNTER/dsr_TransMax %d/%d), SR_pending %d\n",
          module_idP,rnti,frameP,subframe,
          UE_mac_inst[module_idP].scheduling_info.SR_COUNTER,
          (1<<(2+UE_mac_inst[module_idP].physicalConfigDedicated->schedulingRequestConfig->choice.setup.dsr_TransMax)),
          UE_mac_inst[module_idP].scheduling_info.SR_pending);

    //UE_mac_inst[module_idP].ul_active =1;
    return(1); //instruct phy to signal SR
  } else {
    // notify RRC to relase PUCCH/SRS
    // clear any configured dl/ul
    // initiate RA
hbilel's avatar
hbilel committed
314 315 316 317
      if (UE_mac_inst[module_idP].scheduling_info.SR_pending){
          // release all pucch resource
          UE_mac_inst[module_idP].physicalConfigDedicated = NULL;
          UE_mac_inst[module_idP].ul_active=0;
318
          UE_mac_inst[module_idP].BSR_reporting_active=BSR_TRIGGER_NONE;
hbilel's avatar
hbilel committed
319 320 321

          LOG_I(MAC,"[UE %d] Release all SRs \n", module_idP);
      }
322 323 324
    UE_mac_inst[module_idP].scheduling_info.SR_pending=0;
    UE_mac_inst[module_idP].scheduling_info.SR_COUNTER=0;
    return(0);
325 326 327
  }
}

328 329
//------------------------------------------------------------------------------
void
fnabet's avatar
fnabet committed
330 331
ue_send_sdu(
  module_id_t module_idP,
332 333 334 335
	    uint8_t CC_id,
	    frame_t frameP,
	    uint8_t* sdu,
	    uint16_t sdu_len,
fnabet's avatar
fnabet committed
336 337 338 339
  uint8_t eNB_index
)
//------------------------------------------------------------------------------
{
340 341 342 343 344 345

  unsigned char rx_ces[MAX_NUM_CE],num_ce,num_sdu,i,*payload_ptr;
  unsigned char rx_lcids[NB_RB_MAX];
  unsigned short rx_lengths[NB_RB_MAX];
  unsigned char *tx_sdu;

346
  start_meas(&UE_mac_inst[module_idP].rx_dlsch_sdu);
347
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_SDU, VCD_FUNCTION_IN);
348 349 350

  LOG_T(MAC,"sdu: %x.%x.%x\n",sdu[0],sdu[1],sdu[2]);

351
  if (opt_enabled) {
352
    trace_pdu(1, sdu, sdu_len, module_idP, 3, UE_mac_inst[module_idP].crnti,
353
        UE_mac_inst[module_idP].frame, UE_mac_inst[module_idP].subframe, 0, 0);
navid's avatar
navid committed
354 355
    LOG_D(OPT,"[UE %d][DLSCH] Frame %d trace pdu for rnti %x  with size %d\n",
          module_idP, frameP, UE_mac_inst[module_idP].crnti, sdu_len);
356 357 358 359 360
  }

  payload_ptr = parse_header(sdu,&num_ce,&num_sdu,rx_ces,rx_lcids,rx_lengths,sdu_len);

#ifdef DEBUG_HEADER_PARSING
361
  LOG_D(MAC,"[UE %d] ue_send_sdu : Frame %d eNB_index %d : num_ce %d num_sdu %d\n",module_idP,
362
        frameP,eNB_index,num_ce,num_sdu);
363 364 365 366
#endif

#if defined(ENABLE_MAC_PAYLOAD_DEBUG)
  LOG_T(MAC,"[eNB %d] First 32 bytes of DLSCH : \n");
367

368
  for (i=0; i<32; i++) {
369
    LOG_T(MAC,"%x.",sdu[i]);
370
  }
371

372
  LOG_T(MAC,"\n");
373 374
#endif

fnabet's avatar
fnabet committed
375 376
  if (payload_ptr != NULL) {

377 378 379 380
  for (i=0; i<num_ce; i++) {
    //    printf("ce %d : %d\n",i,rx_ces[i]);
    switch (rx_ces[i]) {
    case UE_CONT_RES:
381

382
      LOG_I(MAC,"[UE %d][RAPROC] Frame %d : received contention resolution msg: %x.%x.%x.%x.%x.%x, Terminating RA procedure\n",
383
            module_idP,frameP,payload_ptr[0],payload_ptr[1],payload_ptr[2],payload_ptr[3],payload_ptr[4],payload_ptr[5]);
384 385 386 387 388 389 390 391 392 393 394 395 396

      if (UE_mac_inst[module_idP].RA_active == 1) {
        LOG_I(MAC,"[UE %d][RAPROC] Frame %d : Clearing RA_active flag\n");
        UE_mac_inst[module_idP].RA_active=0;
        // check if RA procedure has finished completely (no contention)
        tx_sdu = &UE_mac_inst[module_idP].CCCH_pdu.payload[3];

        //Note: 3 assumes sizeof(SCH_SUBHEADER_SHORT) + PADDING CE, which is when UL-Grant has TBS >= 9 (64 bits)
        // (other possibility is 1 for TBS=7 (SCH_SUBHEADER_FIXED), or 2 for TBS=8 (SCH_SUBHEADER_FIXED+PADDING or SCH_SUBHEADER_SHORT)
        for (i=0; i<6; i++)
          if (tx_sdu[i] != payload_ptr[i]) {
            LOG_E(MAC,"[UE %d][RAPROC] Contention detected, RA failed\n",module_idP);
            mac_xface->ra_failed(module_idP,CC_id,eNB_index);
397
            UE_mac_inst[module_idP].RA_contention_resolution_timer_active = 0;
398
            VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_SDU, VCD_FUNCTION_OUT);
399 400 401 402 403 404 405 406 407 408 409 410
            return;
          }

        LOG_I(MAC,"[UE %d][RAPROC] Frame %d : Clearing contention resolution timer\n");
        UE_mac_inst[module_idP].RA_contention_resolution_timer_active = 0;
        mac_xface->ra_succeeded(module_idP,CC_id,eNB_index);
      }

      payload_ptr+=6;
      break;

    case TIMING_ADV_CMD:
411
#ifdef DEBUG_HEADER_PARSING
412
      LOG_D(MAC,"[UE] CE %d : UE Timing Advance : %d\n",i,payload_ptr[0]);
413
#endif
414 415 416 417 418
      mac_xface->process_timing_advance(module_idP,CC_id,payload_ptr[0]);
      payload_ptr++;
      break;

    case DRX_CMD:
419
#ifdef DEBUG_HEADER_PARSING
420
      LOG_D(MAC,"[UE] CE %d : UE DRX :",i);
421
#endif
422 423 424
      payload_ptr++;
      break;
    }
425
  }
426 427

  for (i=0; i<num_sdu; i++) {
428
#ifdef DEBUG_HEADER_PARSING
429
    LOG_D(MAC,"[UE] SDU %d : LCID %d, length %d\n",i,rx_lcids[i],rx_lengths[i]);
430
#endif
431
    
432 433
    if (rx_lcids[i] == CCCH) {

434 435 436 437 438 439
      LOG_D(MAC,"[UE %d] rnti %x Frame %d : DLSCH -> DL-CCCH, RRC message (eNB %d, %d bytes)\n",
            module_idP,
            UE_mac_inst[module_idP].crnti,
            frameP,
            eNB_index,
            rx_lengths[i]);
440 441

#if defined(ENABLE_MAC_PAYLOAD_DEBUG)
442
      int j;
443

444
      for (j=0; j<rx_lengths[i]; j++) {
445
        LOG_T(MAC,"%x.",(uint8_t)payload_ptr[j]);
446
      }
447 448 449 450

      LOG_T(MAC,"\n");
#endif
      mac_rrc_data_ind(module_idP,
451
                       CC_id,
452
                       frameP,0, // unknown subframe
453
                       UE_mac_inst[module_idP].crnti,
454
                       CCCH,
455 456 457 458 459
                       (uint8_t*)payload_ptr,
                       rx_lengths[i],
                       ENB_FLAG_NO,
                       eNB_index,
                       0);
460

461
    } else if ((rx_lcids[i] == DCCH) || (rx_lcids[i] == DCCH1)) {
462
      LOG_D(MAC,"[UE %d] Frame %d : DLSCH -> DL-DCCH%d, RRC message (eNB %d, %d bytes)\n", module_idP, frameP, rx_lcids[i],eNB_index,rx_lengths[i]);
463 464
      mac_rlc_data_ind(module_idP,
                       UE_mac_inst[module_idP].crnti,
465
		       eNB_index,
466 467 468
                       frameP,
                       ENB_FLAG_NO,
                       MBMS_FLAG_NO,
469
                       rx_lcids[i],
470 471 472 473
                       (char *)payload_ptr,
                       rx_lengths[i],
                       1,
                       NULL);
474 475 476
 
    } else if ((rx_lcids[i]  < NB_RB_MAX) && (rx_lcids[i] > DCCH1 )) {
      
477
      LOG_D(MAC,"[UE %d] Frame %d : DLSCH -> DL-DTCH%d (eNB %d, %d bytes)\n", module_idP, frameP,rx_lcids[i], eNB_index,rx_lengths[i]);
478 479

#if defined(ENABLE_MAC_PAYLOAD_DEBUG)
480
      int j;
481 482
      for (j=0;j<rx_lengths[i];j++)
	LOG_T(MAC,"%x.",(unsigned char)payload_ptr[j]);
483
      LOG_T(MAC,"\n");
484
#endif
485
      mac_rlc_data_ind(module_idP,
486
		       UE_mac_inst[module_idP].crnti,
487 488
		       eNB_index,
		       frameP,
489 490 491 492 493 494 495 496 497
		       ENB_FLAG_NO,
		       MBMS_FLAG_NO,
		       rx_lcids[i],
		       (char *)payload_ptr,
		       rx_lengths[i],
		       1,
		       NULL);
    } else {
      LOG_E(MAC,"[UE %d] Frame %d : unknown LCID %d (eNB %d)\n", module_idP, frameP,rx_lcids[i], eNB_index);
498 499
    }
    payload_ptr+= rx_lengths[i];
500
  }
fnabet's avatar
fnabet committed
501
  } // end if (payload_ptr != NULL)
502
  
503
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_SDU, VCD_FUNCTION_OUT);
504
  stop_meas(&UE_mac_inst[module_idP].rx_dlsch_sdu);
505 506
}

507 508
void ue_decode_si(module_id_t module_idP,int CC_id,frame_t frameP, uint8_t eNB_index, void *pdu,uint16_t len)
{
509

510
  start_meas(&UE_mac_inst[module_idP].rx_si);
511
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_SI, VCD_FUNCTION_IN);
512

513
  LOG_D(MAC,"[UE %d] Frame %d Sending SI to RRC (LCID Id %d,len %d)\n",module_idP,frameP,BCCH,len);
514

515
  mac_rrc_data_ind(module_idP,
516
                   CC_id,
517
                   frameP,0, // unknown subframe
518
                   SI_RNTI,
519 520 521
                   BCCH,
                   (uint8_t *)pdu,
                   len,
522
                   ENB_FLAG_NO,
523 524
                   eNB_index,
                   0);
525
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_SI, VCD_FUNCTION_OUT);
526
  stop_meas(&UE_mac_inst[module_idP].rx_si);
navid's avatar
navid committed
527 528 529 530 531 532 533
  if (opt_enabled == 1) {
    trace_pdu(0,
	      (uint8_t *)pdu,
	      len,
	      module_idP,
	      4,
	      0xffff,
534
	      UE_mac_inst[module_idP].frame,
navid's avatar
navid committed
535 536 537 538 539 540
	      UE_mac_inst[module_idP].subframe,
	      0,
	      0);
    LOG_D(OPT,"[UE %d][BCH] Frame %d trace pdu for CC_id %d rnti %x with size %d\n",
	    module_idP, frameP, CC_id, 0xffff, len);
  }
541 542
}

543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
void ue_decode_p(module_id_t module_idP,int CC_id,frame_t frameP, uint8_t eNB_index, void *pdu,uint16_t len)
{

  start_meas(&UE_mac_inst[module_idP].rx_p);
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH, VCD_FUNCTION_IN);

  LOG_D(MAC,"[UE %d] Frame %d Sending Paging message to RRC (LCID Id %d,len %d)\n",module_idP,frameP,PCCH,len);

  mac_rrc_data_ind(module_idP,
                   CC_id,
                   frameP,0, // unknown subframe
                   P_RNTI,
                   PCCH,
                   (uint8_t *)pdu,
                   len,
                   ENB_FLAG_NO,
                   eNB_index,
                   0);
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH, VCD_FUNCTION_OUT);
  stop_meas(&UE_mac_inst[module_idP].rx_p);
  if (opt_enabled == 1) {
    trace_pdu(0,
	      (uint8_t *)pdu,
	      len,
	      module_idP,
	      4,
	      P_RNTI,
570
		  UE_mac_inst[module_idP].frame,
571 572 573 574 575 576 577 578
	      UE_mac_inst[module_idP].subframe,
	      0,
	      0);
    LOG_D(OPT,"[UE %d][BCH] Frame %d trace pdu for CC_id %d rnti %x with size %d\n",
	    module_idP, frameP, CC_id, P_RNTI, len);
  }
}

579 580
#ifdef Rel10
unsigned char *parse_mch_header(unsigned char *mac_header,
581 582 583 584 585
                                unsigned char *num_sdu,
                                unsigned char *rx_lcids,
                                unsigned short *rx_lengths,
                                unsigned short tb_length)
{
586 587 588
  unsigned char not_done=1, num_sdus=0, lcid, i;
  unsigned char *mac_header_ptr = mac_header;
  unsigned short length;
589

590
  while (not_done == 1) {
591 592 593 594 595 596 597 598 599 600 601
    if (((SCH_SUBHEADER_FIXED *)mac_header_ptr)->E == 0) {
      not_done = 0;
    }

    lcid = ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->LCID;

    if (lcid < SHORT_PADDING) {// subheader for MSI, MCCH or MTCH
      if (not_done == 0) { // last MAC SDU, length is implicit
        mac_header_ptr++;
        length = tb_length- (mac_header_ptr - mac_header);

602
        for (i=0; i<num_sdus; i++) {
603
          length -= rx_lengths[i];
604
        }
605 606 607 608 609 610 611 612 613
      } else { // not the last MAC SDU
        if ( ((SCH_SUBHEADER_LONG *)mac_header_ptr)->F == 1) {// subheader has length of 3octets
          //    length = ((SCH_SUBHEADER_LONG *)mac_header_ptr)->L;
          length = ((((SCH_SUBHEADER_LONG *)mac_header_ptr)->L_MSB & 0x7f ) << 8 ) | (((SCH_SUBHEADER_LONG *)mac_header_ptr)->L_LSB & 0xff);
          mac_header_ptr += 3;
        } else { // subheader has length of 2octets
          length = ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->L;
          mac_header_ptr += 2;
        }
614
      }
615 616 617 618 619 620 621 622

      rx_lcids[num_sdus] = lcid;
      rx_lengths[num_sdus] = length;
      num_sdus++;
    } else { // subheader for padding
      //     if (lcid == SHORT_PADDING)
      mac_header_ptr++;
    }
623
  }
624

625 626 627 628 629
  *num_sdu = num_sdus;
  return(mac_header_ptr);
}

// this function is for sending mch_sdu from phy to mac
630 631
void ue_send_mch_sdu(module_id_t module_idP, uint8_t CC_id, frame_t frameP, uint8_t *sdu, uint16_t sdu_len, uint8_t eNB_index, uint8_t sync_area)
{
632 633

  unsigned char num_sdu, i, *payload_ptr;
634
  unsigned char rx_lcids[NB_RB_MAX];
635 636
  unsigned short rx_lengths[NB_RB_MAX];

637
  start_meas(&UE_mac_inst[module_idP].rx_mch_sdu);
638
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_MCH_SDU, VCD_FUNCTION_IN);
639

640
  LOG_D(MAC,"[UE %d] Frame %d : process the mch PDU for sync area %d \n",module_idP,frameP, sync_area);
641 642
  LOG_D(MAC,"[UE %d] sdu: %x.%x\n", module_idP,sdu[0], sdu[1]);
  LOG_D(MAC,"[UE %d] parse_mch_header, demultiplex\n",module_idP);
643 644

  payload_ptr = parse_mch_header(sdu, &num_sdu, rx_lcids, rx_lengths, sdu_len);
645
  LOG_D(MAC,"[UE %d] parse_mch_header, found %d sdus\n",module_idP,num_sdu);
646 647

  for (i=0; i<num_sdu; i++) {
648 649 650 651 652 653 654
    if (rx_lcids[i] == MCH_SCHDL_INFO) {
      if (UE_mac_inst[module_idP].mcch_status==1) {
        LOG_I(MAC,"[UE %d] Frame %d : MCH->MSI for sync area %d (eNB %d, %d bytes)\n",module_idP,frameP, sync_area, eNB_index, rx_lengths[i]);
        // ??store necessary scheduling info to ue_mac_inst in order to
        // calculate exact position of interested service (for the complex case has >1 mtch)
        // set msi_status to 1
        UE_mac_inst[module_idP].msi_status = 1;
655
      }
656 657 658
    } else if (rx_lcids[i] == MCCH_LCHANID) {
      LOG_I(MAC,"[UE %d] Frame %d : SDU %d MCH->MCCH for sync area %d (eNB %d, %d bytes)\n",module_idP,frameP, i, sync_area, eNB_index, rx_lengths[i]);
      mac_rrc_data_ind(module_idP,
659
                       CC_id,
660
                       frameP,0, // unknown subframe
661
                       M_RNTI,
662 663 664 665 666 667 668 669
                       MCCH,
                       payload_ptr, rx_lengths[i], 0, eNB_index, sync_area);
    } else if (rx_lcids[i] == MTCH) {
      if (UE_mac_inst[module_idP].msi_status==1) {
        LOG_I(MAC,"[UE %d] Frame %d : MCH->MTCH for sync area %d (eNB %d, %d bytes)\n",module_idP,frameP, sync_area, eNB_index, rx_lengths[i]);

        mac_rlc_data_ind(
          module_idP,
670
          UE_mac_inst[module_idP].crnti,
671 672
          eNB_index,
	  frameP,
673 674 675 676 677 678 679
          ENB_FLAG_NO,
          MBMS_FLAG_YES,
          MTCH, /*+ (maxDRB + 3),*/
          (char *)payload_ptr,
          rx_lengths[i],
          1,
          NULL);
680 681

      }
682 683 684 685 686 687 688 689 690
    } else {
      LOG_W(MAC,"[UE %d] Frame %d : unknown sdu %d rx_lcids[%d]=%d mcch status %d eNB %d \n",
            module_idP,
            frameP,
            rx_lengths[i],
            i,
            rx_lcids[i],
            UE_mac_inst[module_idP].mcch_status, eNB_index);
    }
691

692
    payload_ptr += rx_lengths[i];
693 694
  }

695
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_MCH_SDU, VCD_FUNCTION_OUT);
696
  stop_meas(&UE_mac_inst[module_idP].rx_mch_sdu);
697 698
}

699 700
int8_t ue_get_mbsfn_sf_alloction (module_id_t module_idP, uint8_t mbsfn_sync_area, unsigned char eNB_index)
{
701
  // currently there is one-to-one mapping between sf allocation pattern and sync area
702 703
  if (mbsfn_sync_area >= MAX_MBSFN_AREA) {
    LOG_W( MAC, "[UE %"PRIu8"] MBSFN synchronization area %"PRIu8" out of range for eNB %"PRIu8"\n", module_idP, mbsfn_sync_area, eNB_index );
704
    return -1;
705
  } else if (UE_mac_inst[module_idP].mbsfn_SubframeConfig[mbsfn_sync_area] != NULL) {
706
    return mbsfn_sync_area;
707
  } else {
708
    LOG_W( MAC, "[UE %"PRIu8"] MBSFN Subframe Config pattern %"PRIu8" not found \n", module_idP, mbsfn_sync_area );
709
    return -1;
710 711
  }
}
712

713 714
int ue_query_mch(module_id_t module_idP, uint8_t CC_id, uint32_t frameP, uint32_t subframe, uint8_t eNB_index,uint8_t *sync_area, uint8_t *mcch_active)
{
715

winckel's avatar
winckel committed
716
  int i=0, j=0, ii=0, msi_pos=0, mcch_mcs = - 1;
717
  int mcch_flag=0, mtch_flag=0, msi_flag=0;
718 719
  int mbsfn_period = 0;// 1<<(UE_mac_inst[module_idP].mbsfn_SubframeConfig[0]->radioframeAllocationPeriod);
  int mcch_period = 0;// 32<<(UE_mac_inst[module_idP].mbsfn_AreaInfo[0]->mcch_Config_r9.mcch_RepetitionPeriod_r9);
winckel's avatar
winckel committed
720
  int mch_scheduling_period = -1;
721 722 723

  start_meas(&UE_mac_inst[module_idP].ue_query_mch);

724
  if (UE_mac_inst[module_idP].pmch_Config[0]) {
725
    mch_scheduling_period = 8<<(UE_mac_inst[module_idP].pmch_Config[0]->mch_SchedulingPeriod_r9);
726
  }
727

728
  for (i=0;
729 730 731
       i< UE_mac_inst[module_idP].num_active_mbsfn_area;
       i++ ) {
    // assume, that there is always a mapping
732
    if ((j=ue_get_mbsfn_sf_alloction(module_idP,i,eNB_index)) == -1) {
733
      return -1; // continue;
734
    }
735 736 737 738 739 740

    ii=0;
    msi_pos=0;
    mbsfn_period = 1<<(UE_mac_inst[module_idP].mbsfn_SubframeConfig[0]->radioframeAllocationPeriod);
    mcch_period = 32<<(UE_mac_inst[module_idP].mbsfn_AreaInfo[0]->mcch_Config_r9.mcch_RepetitionPeriod_r9);

741 742
    LOG_D(MAC,
          "[UE %d] Frame %d subframe %d: Checking MBSFN Sync Area %d/%d with SF allocation %d/%d for MCCH and MTCH (mbsfn period %d, mcch period %d,mac sched period (%d,%d))\n",
743
          module_idP,frameP, subframe,i,UE_mac_inst[module_idP].num_active_mbsfn_area,
744 745 746
          j,UE_mac_inst[module_idP].num_sf_allocation_pattern,mbsfn_period,mcch_period,
          mch_scheduling_period,UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->radioframeAllocationOffset);

747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
    // get the real MCS value
    switch (UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.signallingMCS_r9) {
    case 0:
      mcch_mcs = 2;
      break;

    case 1:
      mcch_mcs = 7;
      break;

    case 2:
      mcch_mcs = 13;
      break;

    case 3:
      mcch_mcs = 19;
      break;
    }

    if (frameP % mbsfn_period == UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->radioframeAllocationOffset) { // MBSFN frameP
      if (UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_oneFrame) { // one-frameP format

        if (UE_mac_inst[module_idP].pmch_Config[0]) {
          //  Find the first subframe in this MCH to transmit MSI
          if (frameP % mch_scheduling_period == UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->radioframeAllocationOffset ) {
            while (ii == 0) {
              ii = UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & (0x80>>msi_pos);
              msi_pos++;
            }
          }
        }

        // Check if the subframe is for MSI, MCCH or MTCHs and Set the correspoding flag to 1
        switch (subframe) {
        case 1:
782
          if (mac_xface->frame_parms->frame_type == FDD) {
783
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_FDD_SF1) == MBSFN_FDD_SF1) {
784
              if (msi_pos == 1) {
785
                msi_flag = 1;
786
              }
787 788

              if ( (frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
789
                   ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF1) == MBSFN_FDD_SF1) ) {
790
                mcch_flag = 1;
791
              }
792 793 794 795 796 797 798 799

              mtch_flag = 1;
            }
          }

          break;

        case 2:
800
          if (mac_xface->frame_parms->frame_type == FDD) {
801
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_FDD_SF2) == MBSFN_FDD_SF2) {
802
              if (msi_pos == 2) {
803
                msi_flag = 1;
804
              }
805 806

              if ( (frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
807
                   ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF2) == MBSFN_FDD_SF2) ) {
808
                mcch_flag = 1;
809
              }
810 811 812 813

              mtch_flag = 1;
            }
          }
814

815 816 817
          break;

        case 3:
818
          if (mac_xface->frame_parms->frame_type == TDD) { // TDD
819
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF3) == MBSFN_TDD_SF3) {
820
              if (msi_pos == 1) {
821
                msi_flag = 1;
822
              }
823 824

              if ( (frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
825
                   ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_TDD_SF3) == MBSFN_TDD_SF3) ) {
826
                mcch_flag = 1;
827
              }
828 829 830 831 832

              mtch_flag = 1;
            }
          } else { // FDD
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_FDD_SF3) == MBSFN_FDD_SF3) {
833
              if (msi_pos == 3) {
834
                msi_flag = 1;
835
              }
836 837

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
838
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF3) == MBSFN_FDD_SF3) ) {
839
                mcch_flag = 1;
840
              }
841 842 843 844 845 846 847 848

              mtch_flag = 1;
            }
          }

          break;

        case 4:
849
          if (mac_xface->frame_parms->frame_type == TDD) {
850
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF4) == MBSFN_TDD_SF4) {
851
              if (msi_pos == 2) {
852
                msi_flag = 1;
853
              }
854 855

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
856
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_TDD_SF4) == MBSFN_TDD_SF4) ) {
857
                mcch_flag = 1;
858
              }
859 860 861 862 863 864 865 866

              mtch_flag = 1;
            }
          }

          break;

        case 6:
867
          if (mac_xface->frame_parms->frame_type == FDD) {
868
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_FDD_SF6) == MBSFN_FDD_SF6) {
869
              if (msi_pos == 4) {
870
                msi_flag = 1;
871
              }
872 873

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
874
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF6) == MBSFN_FDD_SF6) ) {
875
                mcch_flag = 1;
876
              }
877 878 879

              mtch_flag = 1;
            }
880
          }
881 882 883 884

          break;

        case 7:
885
          if (mac_xface->frame_parms->frame_type == TDD) { // TDD
886
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF7) == MBSFN_TDD_SF7) {
887
              if (msi_pos == 3) {
888
                msi_flag = 1;
889
              }
890 891

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
892
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_TDD_SF7) == MBSFN_TDD_SF7) ) {
893
                mcch_flag = 1;
894
              }
895 896 897 898 899

              mtch_flag = 1;
            }
          } else { // FDD
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_FDD_SF7) == MBSFN_FDD_SF7) {
900
              if (msi_pos == 5) {
901
                msi_flag = 1;
902
              }
903 904

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
905
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF7) == MBSFN_FDD_SF7) ) {
906
                mcch_flag = 1;
907
              }
908 909 910

              mtch_flag = 1;
            }
911
          }
912 913 914 915

          break;

        case 8:
916
          if (mac_xface->frame_parms->frame_type == TDD) { //TDD
917
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF8) == MBSFN_TDD_SF8) {
918
              if (msi_pos == 4) {
919
                msi_flag = 1;
920
              }
921 922

              if ( (frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
923
                   ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_TDD_SF8) == MBSFN_TDD_SF8) ) {
924
                mcch_flag = 1;
925
              }
926 927 928 929 930

              mtch_flag = 1;
            }
          } else { // FDD
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_FDD_SF8) == MBSFN_FDD_SF8) {
931
              if (msi_pos == 6) {
932
                msi_flag = 1;
933
              }
934 935

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
936
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF8) == MBSFN_FDD_SF8) ) {
937
                mcch_flag = 1;
938
              }
939 940 941 942 943 944 945 946

              mtch_flag = 1;
            }
          }

          break;

        case 9:
947
          if (mac_xface->frame_parms->frame_type == TDD) {
948
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF9) == MBSFN_TDD_SF9) {
949
              if (msi_pos == 5) {
950
                msi_flag = 1;
951
              }
952 953

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
954
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_TDD_SF9) == MBSFN_TDD_SF9) ) {
955
                mcch_flag = 1;
956
              }
957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973

              mtch_flag = 1;
            }
          }

          break;
        }// end switch

        // sf allocation is non-overlapping
        if ((msi_flag==1) || (mcch_flag==1) || (mtch_flag==1)) {
          LOG_D(MAC,"[UE %d] Frame %d Subframe %d: sync area %d SF alloc %d: msi flag %d, mcch flag %d, mtch flag %d\n",
                module_idP, frameP, subframe,i,j,msi_flag,mcch_flag,mtch_flag);

          *sync_area=i;
          break;
        }
      } else { // four-frameP format
974
      }
975
    }
976
  } // end of for
977

978
  stop_meas(&UE_mac_inst[module_idP].ue_query_mch);
979

980
  if ( (mcch_flag==1)) { // || (msi_flag==1))
981
    *mcch_active=1;
982
  }
983

984 985
  if ( (mcch_flag==1) || ((msi_flag==1) && (UE_mac_inst[module_idP].mcch_status==1)) ) {
    return mcch_mcs;
986
  } else if ((mtch_flag==1) && (UE_mac_inst[module_idP].msi_status==1)) {
987
    return UE_mac_inst[module_idP].pmch_Config[0]->dataMCS_r9;
988
  } else {
989
    return -1;
990
  }
991 992 993 994
}

#endif

995
unsigned char generate_ulsch_header(uint8_t *mac_header,
996 997 998 999 1000 1001 1002 1003 1004 1005 1006
                                    uint8_t num_sdus,
                                    uint8_t short_padding,
                                    uint16_t *sdu_lengths,
                                    uint8_t *sdu_lcids,
                                    POWER_HEADROOM_CMD *power_headroom,
                                    uint16_t *crnti,
                                    BSR_SHORT *truncated_bsr,
                                    BSR_SHORT *short_bsr,
                                    BSR_LONG *long_bsr,
                                    unsigned short post_padding)
{
1007 1008 1009 1010 1011 1012 1013

  SCH_SUBHEADER_FIXED *mac_header_ptr = (SCH_SUBHEADER_FIXED *)mac_header;
  unsigned char first_element=0,last_size=0,i;
  unsigned char mac_header_control_elements[16],*ce_ptr;

  LOG_D(MAC,"[UE] Generate ULSCH : num_sdus %d\n",num_sdus);
#ifdef DEBUG_HEADER_PARSING
1014

1015
  for (i=0; i<num_sdus; i++) {
1016
    LOG_T(MAC,"[UE] sdu %d : lcid %d length %d",i,sdu_lcids[i],sdu_lengths[i]);
1017
  }
1018

1019 1020 1021 1022 1023
  LOG_T(MAC,"\n");
#endif
  ce_ptr = &mac_header_control_elements[0];

  if ((short_padding == 1) || (short_padding == 2)) {
1024 1025 1026 1027 1028
    mac_header_ptr->R    = 0;
    mac_header_ptr->E    = 0;
    mac_header_ptr->LCID = SHORT_PADDING;
    first_element=1;
    last_size=1;
1029
  }
1030

1031
  if (short_padding == 2) {
1032 1033 1034 1035 1036 1037
    mac_header_ptr->E = 1;
    mac_header_ptr++;
    mac_header_ptr->R = 0;
    mac_header_ptr->E    = 0;
    mac_header_ptr->LCID = SHORT_PADDING;
    last_size=1;
1038 1039 1040
  }

  if (power_headroom) {
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
    if (first_element>0) {
      mac_header_ptr->E = 1;
      mac_header_ptr++;
    } else {
      first_element=1;
    }

    mac_header_ptr->R = 0;
    mac_header_ptr->E    = 0;
    mac_header_ptr->LCID = POWER_HEADROOM;
    last_size=1;
    *((POWER_HEADROOM_CMD *)ce_ptr)=(*power_headroom);
    ce_ptr+=sizeof(POWER_HEADROOM_CMD);
    LOG_D(MAC, "phr header size %d\n",sizeof(POWER_HEADROOM_CMD));
1055 1056 1057 1058
  }

  if (crnti) {
#ifdef DEBUG_HEADER_PARSING
1059
    LOG_D(MAC,"[UE] CRNTI : %x (first_element %d)\n",*crnti,first_element);
1060
#endif
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075

    if (first_element>0) {
      mac_header_ptr->E = 1;
      mac_header_ptr++;
    } else {
      first_element=1;
    }

    mac_header_ptr->R    = 0;
    mac_header_ptr->E    = 0;
    mac_header_ptr->LCID = CRNTI;
    last_size=1;
    *((uint16_t *)ce_ptr)=(*crnti);
    ce_ptr+=sizeof(uint16_t);
    //    printf("offset %d\n",ce_ptr-mac_header_control_elements);
1076 1077 1078
  }

  if (truncated_bsr) {
1079 1080 1081
    if (first_element>0) {
      mac_header_ptr->E = 1;
      /*
1082
      printf("last subheader : %x (R%d,E%d,LCID%d)\n",*(unsigned char*)mac_header_ptr,
1083 1084 1085 1086 1087 1088 1089 1090 1091
      ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->R,
      ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->E,
      ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->LCID);
       */
      mac_header_ptr++;
    } else {
      first_element=1;
    }

1092
#ifdef DEBUG_HEADER_PARSING
1093
    LOG_D(MAC,"[UE] Scheduler Truncated BSR Header\n");
1094
#endif
1095 1096 1097 1098 1099 1100 1101
    mac_header_ptr->R = 0;
    mac_header_ptr->E    = 0;
    mac_header_ptr->LCID = TRUNCATED_BSR;
    last_size=1;
    *((BSR_TRUNCATED *)ce_ptr)=(*truncated_bsr);
    ce_ptr+=sizeof(BSR_TRUNCATED);
    //    printf("(cont_res) : offset %d\n",ce_ptr-mac_header_control_elements);
1102

1103 1104 1105 1106
  } else if (short_bsr) {
    if (first_element>0) {
      mac_header_ptr->E = 1;
      /*
1107
      printf("last subheader : %x (R%d,E%d,LCID%d)\n",*(unsigned char*)mac_header_ptr,
1108 1109 1110 1111 1112 1113 1114 1115 1116
      ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->R,
      ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->E,
      ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->LCID);
       */
      mac_header_ptr++;
    } else {
      first_element=1;
    }

1117
#ifdef DEBUG_HEADER_PARSING
1118
    LOG_D(MAC,"[UE] Scheduler SHORT BSR Header\n");
1119
#endif
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
    mac_header_ptr->R = 0;
    mac_header_ptr->E    = 0;
    mac_header_ptr->LCID = SHORT_BSR;
    last_size=1;
    *((BSR_SHORT *)ce_ptr)=(*short_bsr);
    ce_ptr+=sizeof(BSR_SHORT);

    //    printf("(cont_res) : offset %d\n",ce_ptr-mac_header_control_elements);
  } else if (long_bsr) {
    if (first_element>0) {
      mac_header_ptr->E = 1;
      /*
1132
      printf("last subheader : %x (R%d,E%d,LCID%d)\n",*(unsigned char*)mac_header_ptr,
1133 1134 1135 1136 1137 1138 1139 1140 1141
      ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->R,
      ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->E,
      ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->LCID);
       */
      mac_header_ptr++;
    } else {
      first_element=1;
    }

1142
#ifdef DEBUG_HEADER_PARSING
1143
    LOG_D(MAC,"[UE] Scheduler Long BSR Header\n");
1144
#endif
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
    mac_header_ptr->R = 0;
    mac_header_ptr->E    = 0;
    mac_header_ptr->LCID = LONG_BSR;
    last_size=1;

    *(ce_ptr)     = (long_bsr->Buffer_size0 << 2) | ((long_bsr->Buffer_size1 & 0x30) >> 4);
    *(ce_ptr + 1) = ((long_bsr->Buffer_size1 & 0x0F) << 4) | ((long_bsr->Buffer_size2 & 0x3C) >> 2);
    *(ce_ptr + 2) = ((long_bsr->Buffer_size2 & 0x03) << 2) | (long_bsr->Buffer_size3 & 0x3F);
    ce_ptr += BSR_LONG_SIZE;

    //    printf("(cont_res) : offset %d\n",ce_ptr-mac_header_control_elements);
1156
  }
1157

1158 1159
  //  printf("last_size %d,mac_header_ptr %p\n",last_size,mac_header_ptr);

1160
  for (i=0; i<num_sdus; i++) {
1161
#ifdef DEBUG_HEADER_PARSING
1162
    LOG_T(MAC,"[UE] sdu subheader %d (lcid %d, %d bytes)\n",i,sdu_lcids[i],sdu_lengths[i]);
1163
#endif
1164

1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
    if ((i == (num_sdus - 1)) && ((short_padding) || (post_padding == 0))) {
        if (first_element>0) {
            mac_header_ptr->E = 1;
      #ifdef DEBUG_HEADER_PARSING
            LOG_D(MAC,"[UE] last subheader : %x (R%d,E%d,LCID%d)\n",*(unsigned char*)mac_header_ptr,
                  ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->R,
                  ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->E,
                  ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->LCID);
      #endif
            mac_header_ptr+=last_size;
        }
        mac_header_ptr->R    = 0;
        mac_header_ptr->E    = 0;
        mac_header_ptr->LCID = sdu_lcids[i];
1179
    }
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
    else {
        if ((first_element>0)) {
          mac_header_ptr->E = 1;
    #ifdef DEBUG_HEADER_PARSING
          LOG_D(MAC,"[UE] last subheader : %x (R%d,E%d,LCID%d)\n",*(unsigned char*)mac_header_ptr,
                ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->R,
                ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->E,
                ((SCH_SUBHEADER_FIXED *)mac_header_ptr)->LCID);
    #endif
          mac_header_ptr+=last_size;
          //      printf("last_size %d,mac_header_ptr %p\n",last_size,mac_header_ptr);
        } else {
          first_element=1;
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
        }

        if (sdu_lengths[i] < 128) {
          ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->R    = 0; // 3
          ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->E    = 0;
          ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->F    = 0;
          ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->LCID = sdu_lcids[i];
          ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->L    = (unsigned char)sdu_lengths[i];
          last_size=2;
    #ifdef DEBUG_HEADER_PARSING
          LOG_D(MAC,"[UE] short sdu\n");
          LOG_T(MAC,"[UE] last subheader : %x (R%d,E%d,LCID%d,F%d,L%d)\n",
                ((uint16_t*)mac_header_ptr)[0],
                ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->R,
                ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->E,
                ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->LCID,
                ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->F,
                ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->L);
    #endif
        } else {
          ((SCH_SUBHEADER_LONG *)mac_header_ptr)->R    = 0;
          ((SCH_SUBHEADER_LONG *)mac_header_ptr)->E    = 0;
          ((SCH_SUBHEADER_LONG *)mac_header_ptr)->F    = 1;
          ((SCH_SUBHEADER_LONG *)mac_header_ptr)->LCID = sdu_lcids[i];
          ((SCH_SUBHEADER_LONG *)mac_header_ptr)->L_MSB    = ((unsigned short) sdu_lengths[i]>>8)&0x7f;
          ((SCH_SUBHEADER_LONG *)mac_header_ptr)->L_LSB    = (unsigned short) sdu_lengths[i]&0xff;
          ((SCH_SUBHEADER_LONG *)mac_header_ptr)->padding  = 0x00;
          last_size=3;
    #ifdef DEBUG_HEADER_PARSING
          LOG_D(MAC,"[UE] long sdu\n");
    #endif
        }
1226
    }
1227
  }
1228

1229
  if (post_padding>0) {// we have lots of padding at the end of the packet
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
    mac_header_ptr->E = 1;
    mac_header_ptr+=last_size;
    // add a padding element
    mac_header_ptr->R    = 0;
    mac_header_ptr->E    = 0;
    mac_header_ptr->LCID = SHORT_PADDING;
    mac_header_ptr++;
  } else { // no end of packet padding
    // last SDU subhead is of fixed type (sdu length implicitly to be computed at UE)
    mac_header_ptr++;
    //mac_header_ptr=last_size; // FIXME: should be ++
1241
  }
1242

1243

1244
  if ((ce_ptr-mac_header_control_elements) > 0) {
1245 1246
    memcpy((void*)mac_header_ptr,mac_header_control_elements,ce_ptr-mac_header_control_elements);
    mac_header_ptr+=(unsigned char)(ce_ptr-mac_header_control_elements);
1247
  }
1248

1249 1250
#ifdef DEBUG_HEADER_PARSING
  LOG_T(MAC," [UE %d] header : ", crnti);
1251

1252
  for (i=0; i<((unsigned char*)mac_header_ptr - mac_header); i++) {
1253
    LOG_T(MAC,"%2x.",mac_header[i]);
1254
  }
1255

1256 1257 1258 1259 1260 1261
  LOG_T(MAC,"\n");
#endif
  return((unsigned char*)mac_header_ptr - mac_header);

}

1262 1263
void ue_get_sdu(module_id_t module_idP,int CC_id,frame_t frameP,sub_frame_t subframe, uint8_t eNB_index,uint8_t *ulsch_buffer,uint16_t buflen, uint8_t *access_mode)
{
1264 1265

  mac_rlc_status_resp_t rlc_status;
hbilel's avatar
hbilel committed
1266 1267
  uint8_t total_rlc_pdu_header_len=0, rlc_pdu_header_len_last=0 ;
  uint16_t buflen_remain = 0;
1268
  uint8_t bsr_len=0,bsr_ce_len=0,bsr_header_len=0;
1269
  uint8_t phr_header_len=0, phr_ce_len=0,phr_len=0;
1270
  uint8_t lcid=0,lcid_rlc_pdu_count=0;
hbilel's avatar
hbilel committed
1271
  boolean_t is_lcid_processed = FALSE;
1272 1273 1274 1275 1276
  uint16_t sdu_lengths[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
  uint8_t sdu_lcids[8]    = { 0, 0, 0, 0, 0, 0, 0, 0 };
  uint8_t payload_offset=0,num_sdus=0;
  uint8_t ulsch_buff[MAX_ULSCH_PAYLOAD_BYTES];
  uint16_t sdu_length_total=0;
calvin wang's avatar
calvin wang committed
1277
  BSR_SHORT bsr_short,bsr_truncated;
1278 1279 1280
  BSR_LONG bsr_long;
  BSR_SHORT *bsr_s=&bsr_short;
  BSR_LONG  *bsr_l=&bsr_long;
calvin wang's avatar
calvin wang committed
1281
  BSR_SHORT *bsr_t=&bsr_truncated;
1282 1283
  POWER_HEADROOM_CMD phr;
  POWER_HEADROOM_CMD *phr_p=&phr;
fnabet's avatar
fnabet committed
1284
  unsigned short short_padding=0, post_padding=0, padding_len=0;
1285 1286
  int j; // used for padding
  // Compute header length
hbilel's avatar
hbilel committed
1287
  int lcg_id = 0;
1288 1289
  int lcg_id_bsr_trunc = 0;
  int highest_priority = 16;
hbilel's avatar
hbilel committed
1290
  int num_lcg_id_with_data = 0;
1291
  
hbilel's avatar
hbilel committed
1292 1293 1294
  LOG_D(MAC,"[UE %d] MAC PROCESS UL TRANSPORT BLOCK at frame%d subframe %d TBS=%d\n",
                        module_idP, frameP, subframe, buflen);

fnabet's avatar
fnabet committed
1295
  
Raymond Knopp's avatar
 
Raymond Knopp committed
1296 1297 1298 1299 1300 1301
  if (CC_id>0) {
    LOG_E(MAC,"Transmission on secondary CCs is not supported yet\n");
    mac_xface->macphy_exit("MAC FATAL  CC_id>0");
    return;
  }

1302
  start_meas(&UE_mac_inst[module_idP].tx_ulsch_sdu);
1303
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GET_SDU, VCD_FUNCTION_IN);
1304

Cedric Roux's avatar
Cedric Roux committed
1305
#ifdef CBA
1306 1307 1308

  if (*access_mode==CBA_ACCESS) {
    LOG_D(MAC,"[UE %d] frameP %d subframe %d try CBA transmission\n",
1309
          module_idP, frameP, subframe);
1310 1311 1312 1313

    //if (UE_mac_inst[module_idP].scheduling_info.LCID_status[DTCH] == LCID_EMPTY)
    if (cba_access(module_idP,frameP,subframe,eNB_index,buflen)==0) {
      *access_mode=POSTPONED_ACCESS;
1314
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GET_SDU, VCD_FUNCTION_OUT);
1315 1316 1317 1318
      return;
    }

    LOG_I(MAC,"[UE %d] frameP %d subframe %d CBA transmission oppurtunity, tbs %d\n",
1319
          module_idP, frameP, subframe,buflen);
1320
  }
1321

1322
#endif
hbilel's avatar
hbilel committed
1323
  bsr_header_len = 0;
1324
  phr_header_len = 1;//sizeof(SCH_SUBHEADER_FIXED);
1325

hbilel's avatar
hbilel committed
1326 1327 1328 1329 1330 1331 1332 1333
  while (lcg_id < MAX_NUM_LCGID) {
     if  (UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcg_id]){
         num_lcg_id_with_data ++;
     }
     lcg_id ++;
  }

  if (num_lcg_id_with_data){
GabrirelCouturier's avatar
GabrirelCouturier committed
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
      LOG_D(MAC,"[UE %d] MAC Tx data pending at frame%d subframe %d nb LCG =%d Bytes for LCG0=%d LCG1=%d LCG2=%d LCG3=%d BSR Trigger status =%d TBS=%d\n",
                            module_idP,
                            frameP,
                            subframe,
                            num_lcg_id_with_data,
                            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[0],
                            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[1],
                            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[2],
                            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[3],
                            UE_mac_inst[module_idP].BSR_reporting_active, buflen);
hbilel's avatar
hbilel committed
1344 1345

  }
GabrirelCouturier's avatar
GabrirelCouturier committed
1346 1347 1348
  //Restart ReTxBSR Timer at new grant indication (36.321)
  if (UE_mac_inst[module_idP].scheduling_info.retxBSR_SF != MAC_UE_BSR_TIMER_NOT_RUNNING){
      UE_mac_inst[module_idP].scheduling_info.retxBSR_SF = get_sf_retxBSRTimer(UE_mac_inst[module_idP].scheduling_info.retxBSR_Timer);
hbilel's avatar
hbilel committed
1349
  }
GabrirelCouturier's avatar
GabrirelCouturier committed
1350

hbilel's avatar
hbilel committed
1351 1352 1353
  // periodicBSR-Timer expires, trigger BSR
  if ((UE_mac_inst[module_idP].scheduling_info.periodicBSR_Timer != MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_infinity)
            && (UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF == 0)){
1354 1355
        // Trigger BSR Periodic
      UE_mac_inst[module_idP].BSR_reporting_active |= BSR_TRIGGER_PERIODIC;
hbilel's avatar
hbilel committed
1356 1357 1358 1359 1360 1361

      LOG_I(MAC,"[UE %d] MAC BSR Triggered PeriodicBSR Timer expiry at frame%d subframe %d TBS=%d\n",
                       module_idP, frameP, subframe, buflen);

    }

1362 1363
  //Compute BSR Length if Regular or Periodic BSR is triggered
  //WARNING: if BSR long is computed, it may be changed to BSR short during or after multiplexing if there remains less than 1 LCGROUP with data after Tx
hbilel's avatar
hbilel committed
1364
  if (UE_mac_inst[module_idP].BSR_reporting_active){
GabrirelCouturier's avatar
GabrirelCouturier committed
1365

1366 1367
	  AssertFatal ((UE_mac_inst[module_idP].BSR_reporting_active & BSR_TRIGGER_PADDING) == 0 , "Inconsistent BSR Trigger=%d !\n",
			  UE_mac_inst[module_idP].BSR_reporting_active);
GabrirelCouturier's avatar
GabrirelCouturier committed
1368

1369 1370 1371 1372 1373
      if (buflen >= 4){
    	  //A Regular or Periodic BSR can only be sent if TBS >= 4 as transmitting only a BSR is not allowed if UE has data to transmit
    	  bsr_header_len = 1;

          if (num_lcg_id_with_data <= 1){
hbilel's avatar
hbilel committed
1374 1375 1376
              bsr_ce_len = sizeof(BSR_SHORT); //1 byte
          }
          else{
fnabet's avatar
fnabet committed
1377
              bsr_ce_len = BSR_LONG_SIZE; //3 bytes
hbilel's avatar
hbilel committed
1378 1379 1380 1381
          }
      }
  }

1382
  bsr_len = bsr_ce_len + bsr_header_len;
1383

fnabet's avatar
fnabet committed
1384
  phr_ce_len = (UE_mac_inst[module_idP].PHR_reporting_active == 1) ? 1 /* sizeof(POWER_HEADROOM_CMD)*/: 0;
1385
  if ((phr_ce_len > 0) && ((phr_ce_len + phr_header_len + bsr_len) <= buflen)){
fnabet's avatar
fnabet committed
1386 1387 1388 1389 1390
    phr_len = phr_ce_len + phr_header_len;
    LOG_D(MAC,"[UE %d] header size info: PHR len %d (ce%d,hdr%d) buff_len %d\n",
          module_idP, phr_len, phr_ce_len, phr_header_len, buflen);
  } else {
    phr_len=0;
1391 1392
    phr_header_len = 0;
    phr_ce_len = 0;
fnabet's avatar
fnabet committed
1393 1394
  }

1395
  // check for UL bandwidth requests and add SR control element
1396 1397

  // check for UL bandwidth requests and add SR control element
1398 1399

  // Check for DCCH first
hbilel's avatar
hbilel committed
1400 1401 1402
// TO DO: Unrool the loop to do it at least once to avoid the if num_sdu
for (lcid=DCCH; lcid < DTCH ; lcid++) {
  if (UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] == LCID_NOT_EMPTY) {
1403

hbilel's avatar
hbilel committed
1404
      is_lcid_processed = FALSE;
1405
      lcid_rlc_pdu_count = 0;
1406

hbilel's avatar
hbilel committed
1407 1408
      //Multiplex all available DCCH RLC PDUs considering to multiplex the last PDU each time for maximize the data
      //Adjust at the end of the loop
1409
      while ((!is_lcid_processed) && (bsr_len + phr_len + total_rlc_pdu_header_len + sdu_length_total + MIN_MAC_HDR_RLC_SIZE <= buflen)) {
1410

1411
          buflen_remain = buflen - (bsr_len + phr_len + total_rlc_pdu_header_len + sdu_length_total + 1);
hbilel's avatar
hbilel committed
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421

          rlc_status = mac_rlc_status_ind(module_idP,
                          UE_mac_inst[module_idP].crnti,
                          eNB_index,
                          frameP,
                          ENB_FLAG_NO,
                          MBMS_FLAG_NO, // eNB_index
                                          lcid,
                                          buflen_remain);

1422 1423
          AssertFatal ( UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid] >=  rlc_status.bytes_in_buffer, "Inconsistent BO! for LCID=%d MAC=%d RLC=%d RLC PDU nb=%d Frame %d Subrame %d\n",
                  lcid,UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid],rlc_status.bytes_in_buffer,lcid_rlc_pdu_count,frameP,subframe);
hbilel's avatar
hbilel committed
1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487

          if (rlc_status.bytes_in_buffer > 0) {


          LOG_D(MAC, "[UE %d] Frame %d : UL-DCCH -> ULSCH, RLC SRB%d has %d bytes to "
                "send (Transport Block size %d BSR size=%d PHR=%d SDU Length Total %d , mac header len %d BSR byte before Tx=%d)\n",
                module_idP,frameP, lcid,UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid],buflen,bsr_len,phr_len,sdu_length_total,total_rlc_pdu_header_len,UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]]);


          sdu_lengths[num_sdus] = mac_rlc_data_req(module_idP,
                             UE_mac_inst[module_idP].crnti,
                             eNB_index,
                             frameP,
                             ENB_FLAG_NO,
                             MBMS_FLAG_NO,
                                             lcid,
                                             (char *)&ulsch_buff[sdu_length_total]);


            AssertFatal (UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid] >= sdu_lengths[num_sdus], "LCID=%d RLC has segmented %d bytes but MAC has max=%d\n",
                    lcid,sdu_lengths[num_sdus],UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid]);



          sdu_length_total += sdu_lengths[num_sdus];
          sdu_lcids[num_sdus] = lcid;
          LOG_D(MAC,"[UE %d] TX Multiplex RLC PDU TX Got %d bytes for SRB%d\n",module_idP,sdu_lengths[num_sdus],lcid);
          //header_len +=2;
          // update LCID remain buffer
          UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid] -= sdu_lengths[num_sdus];
          /* Update BSR : substract transmitted data */
          if (UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] >= sdu_lengths[num_sdus]){
              UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] -= sdu_lengths[num_sdus] ;
          }
          else {
              LOG_I(MAC, "[UE %d] Frame %d Subframe%d: WARNING Buffer occupancy =%d for LCGID%d is lower than data transmitted=%d for LCID%d\n",
                        module_idP,frameP,subframe,
                        UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]],
                        UE_mac_inst[module_idP].scheduling_info.LCGID[lcid],
                        sdu_lengths[num_sdus],lcid);
              UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] = 0;
          }

          //Update the number of LCGID with data as BSR shall reflect status after BSR transmission
          if ((num_lcg_id_with_data > 1) && (UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] == 0))
          {
              num_lcg_id_with_data --;
              // Change BSR size to BSR SHORT if num_lcg_id_with_data becomes to 1
              if ((bsr_len) && (num_lcg_id_with_data == 1))
              {
                  bsr_ce_len = sizeof(BSR_SHORT);
                  bsr_len = bsr_ce_len + bsr_header_len;
              }

          }

          if (buflen == (bsr_len + phr_len + total_rlc_pdu_header_len + sdu_length_total + 1)) {
              //No more remaining TBS after this PDU
              //exit the function
              rlc_pdu_header_len_last = 1;
              is_lcid_processed = TRUE;
          }
          else {
              rlc_pdu_header_len_last = (sdu_lengths[num_sdus] > 128 ) ? 3 : 2 ;
1488

hbilel's avatar
hbilel committed
1489 1490 1491 1492 1493 1494 1495
              //Change to 1 byte if it does not fit in the TBS, ie last PDU
              if (buflen <= (bsr_len + phr_len + total_rlc_pdu_header_len + rlc_pdu_header_len_last + sdu_length_total)) {
                  rlc_pdu_header_len_last = 1;
                  is_lcid_processed = TRUE;
              }
          }

1496 1497 1498 1499 1500
          //Update number of SDU
          num_sdus ++;

          //Update total MAC Header size for RLC PDUs and save last one
          total_rlc_pdu_header_len += rlc_pdu_header_len_last;
hbilel's avatar
hbilel committed
1501 1502 1503 1504 1505 1506

          } //end if (rlc_status.bytes_in_buffer > 0)
          else {
              // Switch to next LCID or exit the whole loop
              is_lcid_processed = TRUE;
          }
1507
          lcid_rlc_pdu_count ++;
1508
   }
1509

hbilel's avatar
hbilel committed
1510 1511 1512
    UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] = LCID_EMPTY;
   }
}
1513 1514


hbilel's avatar
hbilel committed
1515 1516 1517 1518
// Now Check for DTCH first
// TO DO: do it according to Logical Channel Prioritization if at least 2 DTCH
for (lcid=DTCH; lcid < MAX_NUM_LCID ; lcid++) {
if (UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] == LCID_NOT_EMPTY) {
1519

hbilel's avatar
hbilel committed
1520
    is_lcid_processed = FALSE;
1521
    lcid_rlc_pdu_count = 0;
1522

hbilel's avatar
hbilel committed
1523 1524
    //Multiplex all available DTCH RLC PDUs considering to multiplex the last PDU each time for maximize the data
    //Adjust at the end of the loop
1525
    while ((!is_lcid_processed) && (bsr_len + phr_len + total_rlc_pdu_header_len + sdu_length_total + MIN_MAC_HDR_RLC_SIZE <= buflen)) {
1526

1527
        buflen_remain = buflen - (bsr_len + phr_len + total_rlc_pdu_header_len + sdu_length_total + 1);
1528

hbilel's avatar
hbilel committed
1529 1530 1531 1532 1533 1534 1535 1536
        rlc_status = mac_rlc_status_ind(module_idP,
                        UE_mac_inst[module_idP].crnti,
                        eNB_index,
                        frameP,
                        ENB_FLAG_NO,
                        MBMS_FLAG_NO, // eNB_index
                                        lcid,
                                        buflen_remain);
1537

1538 1539
          AssertFatal ( UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid] >=  rlc_status.bytes_in_buffer, "Inconsistent BO! for LCID=%d MAC=%d RLC=%d RLC PDU nb=%d Frame %d Subrame %d\n",
                  lcid,UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid],rlc_status.bytes_in_buffer,lcid_rlc_pdu_count,frameP,subframe);
hbilel's avatar
hbilel committed
1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557

        if (rlc_status.bytes_in_buffer > 0) {


        LOG_D(MAC, "[UE %d] Frame %d : UL-DTCH -> ULSCH, RLC LCID%d has %d bytes to "
              "send (Transport Block size %d BSR size=%d PHR=%d SDU Length Total %d , mac header len %d BSR byte before Tx=%d)\n",
              module_idP,frameP, lcid,UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid],buflen,bsr_len,phr_len,sdu_length_total,total_rlc_pdu_header_len,UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]]);


        sdu_lengths[num_sdus] = mac_rlc_data_req(module_idP,
                           UE_mac_inst[module_idP].crnti,
                           eNB_index,
                           frameP,
                           ENB_FLAG_NO,
                           MBMS_FLAG_NO,
                                           lcid,
                                           (char *)&ulsch_buff[sdu_length_total]);

1558 1559 1560
        AssertFatal (sdu_lengths[num_sdus] < MAX_ULSCH_PAYLOAD_BYTES, "LCID=%d RLC PDU size = %d is too big\n",
                lcid,sdu_lengths[num_sdus]);

hbilel's avatar
hbilel committed
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614

          AssertFatal (UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid] >= sdu_lengths[num_sdus], "LCID=%d RLC has segmented %d bytes but MAC has max=%d\n",
                  lcid,sdu_lengths[num_sdus],UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid]);



        sdu_length_total += sdu_lengths[num_sdus];
        sdu_lcids[num_sdus] = lcid;
        LOG_D(MAC,"[UE %d] TX Multiplex RLC PDU TX Got %d bytes for LCID%d\n",module_idP,sdu_lengths[num_sdus],lcid);
        //header_len +=2;
        // update LCID remain buffer
        UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid] -= sdu_lengths[num_sdus];
        /* Update BSR : substract transmitted data */
        if (UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] >= sdu_lengths[num_sdus]){
            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] -= sdu_lengths[num_sdus] ;
        }
        else {
            LOG_I(MAC, "[UE %d] Frame %d Subframe%d: WARNING Buffer occupancy =%d for LCGID%d is lower than data transmitted=%d for LCID%d\n",
                      module_idP,frameP,subframe,
                      UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]],
                      UE_mac_inst[module_idP].scheduling_info.LCGID[lcid],
                      sdu_lengths[num_sdus],lcid);
            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] = 0;
        }

        //Update the number of LCGID with data as BSR shall reflect status after BSR transmission
        if ((num_lcg_id_with_data > 1) && (UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] == 0))
        {
            num_lcg_id_with_data --;
            // Change BSR size to BSR SHORT if num_lcg_id_with_data becomes to 1
            if ((bsr_len) && (num_lcg_id_with_data == 1))
            {
                bsr_ce_len = sizeof(BSR_SHORT);
                bsr_len = bsr_ce_len + bsr_header_len;
            }

        }

        if (buflen == (bsr_len + phr_len + total_rlc_pdu_header_len + sdu_length_total + 1)) {
            //No more remaining TBS after this PDU
            //exit the function
            rlc_pdu_header_len_last = 1;
            is_lcid_processed = TRUE;
        }
        else {
            rlc_pdu_header_len_last = (sdu_lengths[num_sdus] > 128 ) ? 3 : 2 ;

            //Change to 1 byte if it does not fit in the TBS, ie last PDU
            if (buflen <= (bsr_len + phr_len + total_rlc_pdu_header_len + rlc_pdu_header_len_last + sdu_length_total)) {
                rlc_pdu_header_len_last = 1;
                is_lcid_processed = TRUE;
            }
        }

1615 1616 1617 1618 1619
        //Update number of SDU
        num_sdus ++;

        //Update total MAC Header size for RLC PDUs and save last one
        total_rlc_pdu_header_len += rlc_pdu_header_len_last;
hbilel's avatar
hbilel committed
1620 1621 1622 1623 1624 1625

        } //end if (rlc_status.bytes_in_buffer > 0)
        else {
            // Switch to next LCID or exit the whole loop
            is_lcid_processed = TRUE;
        }
1626
        lcid_rlc_pdu_count ++;
hbilel's avatar
hbilel committed
1627 1628 1629 1630 1631
 }

  UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] = LCID_EMPTY;
 }
}
fnabet's avatar
fnabet committed
1632

hbilel's avatar
hbilel committed
1633
  //lcgid= get_bsr_lcgid(module_idP);
1634

1635 1636 1637
  // Compute BSR Values and update Nb LCGID with data after multiplexing
  num_lcg_id_with_data = 0;
  lcg_id_bsr_trunc = 0;
hbilel's avatar
hbilel committed
1638 1639
  for (lcg_id=0;lcg_id<MAX_NUM_LCGID;lcg_id++){
      UE_mac_inst[module_idP].scheduling_info.BSR[lcg_id] = locate_BsrIndexByBufferSize(BSR_TABLE, BSR_TABLE_SIZE, UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcg_id]);
1640 1641 1642 1643 1644

      if  (UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcg_id]){
          num_lcg_id_with_data ++;
          lcg_id_bsr_trunc = lcg_id;
      }
hbilel's avatar
hbilel committed
1645 1646
  }

1647

GabrirelCouturier's avatar
GabrirelCouturier committed
1648 1649
  if (bsr_ce_len) {
      //Print updated BSR when sent
hbilel's avatar
hbilel committed
1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
      LOG_D(MAC,"[UE %d] Remaining Buffer after Tx frame%d subframe %d nb LCG =%d Bytes for LCG0=%d LCG1=%d LCG2=%d LCG3=%d BSR Trigger status =%d TBS=%d\n",
                            module_idP,
                            frameP,
                            subframe,
                            num_lcg_id_with_data,
                            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[0],
                            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[1],
                            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[2],
                            UE_mac_inst[module_idP].scheduling_info.BSR_bytes[3],
                            UE_mac_inst[module_idP].BSR_reporting_active, buflen);

      LOG_D(MAC,"[UE %d] Frame %d Subframe %d TX BSR Regular or Periodic size=%d BSR0=%d BSR1=%d BSR2=%d BSR3=%d\n",module_idP,frameP,subframe,bsr_ce_len,
GabrirelCouturier's avatar
GabrirelCouturier committed
1662 1663 1664 1665 1666 1667
              UE_mac_inst[module_idP].scheduling_info.BSR[0],
              UE_mac_inst[module_idP].scheduling_info.BSR[1],
              UE_mac_inst[module_idP].scheduling_info.BSR[2],
              UE_mac_inst[module_idP].scheduling_info.BSR[3]);
  }

1668

1669
  // build PHR and update the timers
1670
  if (phr_ce_len == sizeof(POWER_HEADROOM_CMD)) {
Raymond Knopp's avatar
 
Raymond Knopp committed
1671 1672 1673 1674 1675
    phr_p->PH = get_phr_mapping(module_idP,CC_id,eNB_index);
    phr_p->R  = 0;
    LOG_D(MAC,"[UE %d] Frame %d report PHR with mapping (%d->%d) for LCID %d\n",
          module_idP,frameP, mac_xface->get_PHR(module_idP,CC_id,eNB_index), phr_p->PH,POWER_HEADROOM);
    update_phr(module_idP,CC_id);
1676
  } else {
1677
    phr_p=NULL;
1678
  }
1679

1680
  LOG_T(MAC,"[UE %d] Frame %d: bsr s %p bsr_l %p, phr_p %p\n",  module_idP,frameP,bsr_s, bsr_l, phr_p);
1681

1682 1683

  // Check BSR padding: it is done after PHR according to Logical Channel Prioritization order
hbilel's avatar
hbilel committed
1684
  // Check for max padding size, ie MAC Hdr for last RLC PDU = 1
1685 1686 1687 1688 1689 1690
  /* For Padding BSR:
     -	if the number of padding bits is equal to or larger than the size of the Short BSR plus its subheader but smaller than the size of the Long BSR plus its subheader:
         -	if more than one LCG has data available for transmission in the TTI where the BSR is transmitted: report Truncated BSR of the LCG with the highest priority logical channel with data available for transmission;
         -	else report Short BSR.
     -	else if the number of padding bits is equal to or larger than the size of the Long BSR plus its subheader, report Long BSR.
   */
hbilel's avatar
hbilel committed
1691
  if (sdu_length_total) {
1692
      padding_len = buflen - (bsr_len + phr_len + total_rlc_pdu_header_len - rlc_pdu_header_len_last + sdu_length_total + 1);
hbilel's avatar
hbilel committed
1693 1694 1695 1696 1697
  }
  else {
      padding_len = buflen - (bsr_len + phr_len);
  }

1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754

   if ((padding_len) && (bsr_len == 0))
   {
	   /* if the number of padding bits is equal to or larger than the size of the Long BSR plus its subheader, report Long BSR*/
     if (padding_len >= (1+BSR_LONG_SIZE))
     {
    	 bsr_ce_len = BSR_LONG_SIZE;
    	 bsr_header_len = 1;
         // Trigger BSR Padding
       UE_mac_inst[module_idP].BSR_reporting_active |= BSR_TRIGGER_PADDING;


     } else if (padding_len >= (1+sizeof(BSR_SHORT))) {
    	 bsr_ce_len = sizeof(BSR_SHORT);
    	 bsr_header_len = 1;

    	 if (num_lcg_id_with_data > 1)
    	 {
    	  // REPORT TRUNCATED BSR
       	  //Get LCGID of highest priority LCID with data
    		 for (lcid=DCCH; lcid < MAX_NUM_LCID ; lcid++) {
    			 if (UE_mac_inst[module_idP].logicalChannelConfig[lcid] != NULL) {
        			 lcg_id = UE_mac_inst[module_idP].scheduling_info.LCGID[lcid];

        			 if ((lcg_id < MAX_NUM_LCGID) && (UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcg_id])
        					 && (UE_mac_inst[module_idP].logicalChannelConfig[lcid]->ul_SpecificParameters->priority <= highest_priority)) {
        				 highest_priority = UE_mac_inst[module_idP].logicalChannelConfig[lcid]->ul_SpecificParameters->priority;
        				 lcg_id_bsr_trunc = lcg_id;
        			 }
    			 }
    		 }
    	 }
    	 else
    	 {
    		 //Report SHORT BSR, clear bsr_t
    		 bsr_t = NULL;
    	 }

       // Trigger BSR Padding
       UE_mac_inst[module_idP].BSR_reporting_active |= BSR_TRIGGER_PADDING;
     }
 	 bsr_len = bsr_header_len + bsr_ce_len;
   }

   //Fill BSR Infos
   if (bsr_ce_len == 0 ) {
     bsr_s = NULL;
     bsr_l = NULL;
     bsr_t = NULL;
   } else if (bsr_ce_len == BSR_LONG_SIZE) {
     bsr_s = NULL;
     bsr_t = NULL;
     bsr_l->Buffer_size0 = UE_mac_inst[module_idP].scheduling_info.BSR[LCGID0];
     bsr_l->Buffer_size1 = UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1];
     bsr_l->Buffer_size2 = UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2];
     bsr_l->Buffer_size3 = UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3];

hbilel's avatar
hbilel committed
1755
     LOG_I(MAC, "[UE %d] Frame %d subframe %d BSR Trig=%d report long BSR (level LCGID0 %d,level LCGID1 %d,level LCGID2 %d,level LCGID3 %d)\n", module_idP,frameP,subframe,
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
    	   UE_mac_inst[module_idP].BSR_reporting_active,
           UE_mac_inst[module_idP].scheduling_info.BSR[LCGID0],
           UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1],
           UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2],
           UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3]);

   } else if (bsr_ce_len == sizeof(BSR_SHORT)) {
     bsr_l = NULL;
     if ((bsr_t != NULL) && (UE_mac_inst[module_idP].BSR_reporting_active & BSR_TRIGGER_PADDING)) {
    	 //Truncated BSR
    	 bsr_s = NULL;
    	 bsr_t->LCGID = lcg_id_bsr_trunc;
    	 bsr_t->Buffer_size = UE_mac_inst[module_idP].scheduling_info.BSR[lcg_id_bsr_trunc];

hbilel's avatar
hbilel committed
1770 1771
         LOG_I(MAC,"[UE %d] Frame %d subframe %d BSR Trig=%d report TRUNCATED BSR with level %d for LCGID %d\n",
               module_idP, frameP, subframe, UE_mac_inst[module_idP].BSR_reporting_active, UE_mac_inst[module_idP].scheduling_info.BSR[lcg_id_bsr_trunc],lcg_id_bsr_trunc);
1772 1773 1774 1775 1776 1777 1778 1779

     }
     else
     {
    	 bsr_t = NULL;
         bsr_s->LCGID = lcg_id_bsr_trunc;
         bsr_s->Buffer_size = UE_mac_inst[module_idP].scheduling_info.BSR[lcg_id_bsr_trunc];

hbilel's avatar
hbilel committed
1780 1781
         LOG_I(MAC,"[UE %d] Frame %d subframe %d BSR Trig=%d report SHORT BSR with level %d for LCGID %d\n",
               module_idP, frameP, subframe, UE_mac_inst[module_idP].BSR_reporting_active, UE_mac_inst[module_idP].scheduling_info.BSR[lcg_id_bsr_trunc],lcg_id_bsr_trunc);
1782 1783 1784
     }
   }

hbilel's avatar
hbilel committed
1785 1786 1787
// 1-bit padding or 2-bit padding  special padding subheader
// Check for max padding size, ie MAC Hdr for last RLC PDU = 1
   if (sdu_length_total) {
1788
       padding_len = buflen - (bsr_len + phr_len + total_rlc_pdu_header_len - rlc_pdu_header_len_last + sdu_length_total + 1);
hbilel's avatar
hbilel committed
1789 1790 1791 1792 1793
   }
   else {
       padding_len = buflen - (bsr_len + phr_len);
   }

fnabet's avatar
fnabet committed
1794 1795 1796
  if (padding_len <= 2) {
    short_padding = padding_len;
    // only add padding header
1797
    post_padding = 0;
hbilel's avatar
hbilel committed
1798 1799
    //update total MAC Hdr size for RLC data
    if (sdu_length_total) {
1800
        total_rlc_pdu_header_len = total_rlc_pdu_header_len - rlc_pdu_header_len_last + 1;
hbilel's avatar
hbilel committed
1801
        rlc_pdu_header_len_last = 1;
1802
   }
hbilel's avatar
hbilel committed
1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814
  }
  else if (sdu_length_total) {
      post_padding = buflen - (bsr_len + phr_len + total_rlc_pdu_header_len + sdu_length_total + 1);
      // If by adding MAC Hdr for last RLC PDU the padding is 0 then set MAC Hdr for last RLC PDU = 1 and compute 1 or 2 byte padding
      if (post_padding == 0) {
          total_rlc_pdu_header_len -= rlc_pdu_header_len_last;
          padding_len = buflen - (bsr_len + phr_len + total_rlc_pdu_header_len + sdu_length_total + 1);
          short_padding = padding_len;
          total_rlc_pdu_header_len ++;
      }
  }
  else {
fnabet's avatar
fnabet committed
1815
    if (padding_len == buflen) {// nona mac pdu
1816 1817 1818 1819 1820
      *access_mode=CANCELED_ACCESS;
    }

    short_padding = 0;

hbilel's avatar
hbilel committed
1821
    post_padding = buflen - (bsr_len + phr_len + total_rlc_pdu_header_len + sdu_length_total + 1);
1822
  }
1823

1824 1825
  // Generate header
  // if (num_sdus>0) {
1826

1827
  payload_offset = generate_ulsch_header(ulsch_buffer,  // mac header
1828 1829 1830 1831 1832 1833
                                         num_sdus,      // num sdus
                                         short_padding,            // short pading
                                         sdu_lengths,  // sdu length
                                         sdu_lcids,    // sdu lcid
                                         phr_p,  // power headroom
                                         NULL,  // crnti
calvin wang's avatar
calvin wang committed
1834
                                         bsr_t,  // truncated bsr
1835 1836 1837 1838
                                         bsr_s, // short bsr
                                         bsr_l,
                                         post_padding); // long_bsr

1839
  LOG_D(MAC,
hbilel's avatar
hbilel committed
1840 1841
        "[UE %d] Generate header :bufflen %d  sdu_length_total %d, num_sdus %d, sdu_lengths[0] %d, sdu_lcids[0] %d => payload offset %d,  total_rlc_pdu_header_len %d, padding %d,post_padding %d, bsr len %d, phr len %d, reminder %d \n",
        module_idP,buflen, sdu_length_total,num_sdus,sdu_lengths[0],sdu_lcids[0],payload_offset, total_rlc_pdu_header_len,
1842
        short_padding,post_padding, bsr_len, phr_len,buflen-sdu_length_total-payload_offset);
1843
  // cycle through SDUs and place in ulsch_buffer
hbilel's avatar
hbilel committed
1844 1845 1846
  if (sdu_length_total) {
      memcpy(&ulsch_buffer[payload_offset],ulsch_buff,sdu_length_total);
  }
1847

1848
  // fill remainder of DLSCH with random data
1849 1850 1851 1852
  if (post_padding) {
      for (j=0; j<(buflen-sdu_length_total-payload_offset); j++) {
        ulsch_buffer[payload_offset+sdu_length_total+j] = (char)(taus()&0xff);
      }
1853
  }
1854
  LOG_D(MAC,"[UE %d][SR] Gave SDU to PHY, clearing any scheduling request\n",
1855
        module_idP,payload_offset, sdu_length_total);
1856 1857
  UE_mac_inst[module_idP].scheduling_info.SR_pending=0;
  UE_mac_inst[module_idP].scheduling_info.SR_COUNTER=0;
1858 1859 1860 1861

  /* Actions when a BSR is sent */
  if (bsr_ce_len)
  {
hbilel's avatar
hbilel committed
1862 1863 1864
      LOG_D(MAC,"[UE %d] MAC BSR Sent !! bsr (ce%d,hdr%d) buff_len %d\n",
              module_idP, bsr_ce_len, bsr_header_len, buflen);

1865 1866 1867
	  // Reset ReTx BSR Timer
	  UE_mac_inst[module_idP].scheduling_info.retxBSR_SF = get_sf_retxBSRTimer(UE_mac_inst[module_idP].scheduling_info.retxBSR_Timer);

hbilel's avatar
hbilel committed
1868
	  LOG_D(MAC,"[UE %d] MAC ReTx BSR Timer Reset =%d\n",
1869 1870 1871 1872 1873 1874 1875
			  UE_mac_inst[module_idP].scheduling_info.retxBSR_SF);

	  // Reset Periodic Timer except when BSR is truncated
	  if ((bsr_t == NULL) && (UE_mac_inst[module_idP].scheduling_info.periodicBSR_Timer != MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_infinity))
	  {
		  UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF = get_sf_periodicBSRTimer(UE_mac_inst[module_idP].scheduling_info.periodicBSR_Timer);

hbilel's avatar
hbilel committed
1876
		  LOG_D(MAC,"[UE %d] MAC Periodic BSR Timer Reset =%d\n",
1877 1878 1879 1880 1881 1882
				  UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF);

	  }

	  // Reset BSR Trigger flags
	  UE_mac_inst[module_idP].BSR_reporting_active = BSR_TRIGGER_NONE;
calvin wang's avatar
calvin wang committed
1883
  }
1884

1885
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GET_SDU, VCD_FUNCTION_OUT);
1886
  stop_meas(&UE_mac_inst[module_idP].tx_ulsch_sdu);
navid's avatar
navid committed
1887 1888
  
  if (opt_enabled) {
1889
    trace_pdu(0, ulsch_buffer, buflen, module_idP, 3, UE_mac_inst[module_idP].crnti, UE_mac_inst[module_idP].frame, UE_mac_inst[module_idP].subframe, 0, 0);
navid's avatar
navid committed
1890
    LOG_D(OPT,"[UE %d][ULSCH] Frame %d trace pdu for rnti %x  with size %d\n",
1891
          module_idP, UE_mac_inst[module_idP].frame, UE_mac_inst[module_idP].subframe, UE_mac_inst[module_idP].crnti, buflen);
navid's avatar
navid committed
1892
  }
1893 1894
}

1895
//------------------------------------------------------------------------------
1896 1897 1898 1899 1900 1901 1902
// called at each subframe
// Performs :
// 1. Trigger PDCP every 5ms
// 2. Call RRC for link status return to PHY
// 3. Perform SR/BSR procedures for scheduling feedback
// 4. Perform PHR procedures

1903 1904 1905 1906 1907 1908 1909 1910 1911
UE_L2_STATE_t
ue_scheduler(
  const module_id_t    module_idP,
  const frame_t        frameP,
  const sub_frame_t    subframeP,
  const lte_subframe_t directionP,
  const uint8_t        eNB_indexP,
  const int            CC_id)
//------------------------------------------------------------------------------
1912
{
1913 1914
  int lcid; // lcid index
  int TTI= 1;
winckel's avatar
winckel committed
1915 1916
  int bucketsizeduration = -1;
  int bucketsizeduration_max = -1;
1917
  // mac_rlc_status_resp_t rlc_status[MAX_NUM_LCGID]; // 4
1918
  // int8_t lcg_id;
1919
  struct RACH_ConfigCommon *rach_ConfigCommon = (struct RACH_ConfigCommon *)NULL;
1920
  protocol_ctxt_t   ctxt;
GabrirelCouturier's avatar
GabrirelCouturier committed
1921

1922
#if defined(ENABLE_ITTI)
1923 1924 1925 1926
  MessageDef   *msg_p;
  const char   *msg_name;
  instance_t    instance;
  int           result;
1927
#endif
1928
  start_meas(&UE_mac_inst[module_idP].ue_scheduler);
1929
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_IN);
1930

1931
  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, module_idP, ENB_FLAG_NO, UE_mac_inst[module_idP].crnti, frameP, subframeP,eNB_indexP);
1932 1933
#if defined(ENABLE_ITTI)

1934 1935 1936
  do {
    // Checks if a message has been sent to MAC sub-task
    itti_poll_msg (TASK_MAC_UE, &msg_p);
1937

1938 1939 1940
    if (msg_p != NULL) {
      msg_name = ITTI_MSG_NAME (msg_p);
      instance = ITTI_MSG_INSTANCE (msg_p);
1941

1942 1943 1944 1945 1946
      switch (ITTI_MSG_ID(msg_p)) {
      case RRC_MAC_CCCH_DATA_REQ:
        LOG_I(MAC, "Received %s from %s: instance %d, frameP %d, eNB_index %d\n",
              msg_name, ITTI_MSG_ORIGIN_NAME(msg_p), instance,
              RRC_MAC_CCCH_DATA_REQ (msg_p).frame, RRC_MAC_CCCH_DATA_REQ (msg_p).enb_index);
1947

1948 1949
        // TODO process CCCH data req.
        break;
1950 1951


1952 1953 1954
      default:
        LOG_E(MAC, "Received unexpected message %s\n", msg_name);
        break;
1955
      }
1956 1957 1958 1959

      result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p);
      AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
    }
1960
  } while(msg_p != NULL);
1961

1962 1963
#endif

1964 1965
  //Mac_rlc_xface->frameP=frameP;
  //Rrc_xface->Frame_index=Mac_rlc_xface->frameP;
1966
  //if (subframe%5 == 0)
1967
  //LG#ifdef EXMIMO
1968
  pdcp_run(&ctxt);
1969
  //#endif
1970 1971
  UE_mac_inst[module_idP].frame = frameP;
  UE_mac_inst[module_idP].subframe = subframeP;
1972 1973

#ifdef CELLULAR
1974
  rrc_rx_tx(module_idP, frameP, 0, eNB_indexP);
1975
#else
1976

1977
  switch (rrc_rx_tx(&ctxt,
1978 1979
                    eNB_indexP,
                    CC_id)) {
1980 1981
  case RRC_OK:
    break;
1982

1983 1984
  case RRC_ConnSetup_failed:
    LOG_E(MAC,"RRCConnectionSetup failed, returning to IDLE state\n");
1985
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
1986
    stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
1987 1988
    return(CONNECTION_LOST);
    break;
1989

1990 1991
  case RRC_PHY_RESYNCH:
    LOG_E(MAC,"RRC Loss of synch, returning PHY_RESYNCH\n");
1992
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
1993
    stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
1994
    return(PHY_RESYNCH);
1995

1996
  case RRC_Handover_failed:
1997
    LOG_N(MAC,"Handover failure for UE %d eNB_index %d\n",module_idP,eNB_indexP);
1998
    //Invalid...need to add another MAC UE state for re-connection procedure
1999
    mac_xface->phy_config_afterHO_ue(module_idP,0,eNB_indexP,(MobilityControlInfo_t *)NULL,1);
2000 2001
    //return(3);
    break;
2002

2003 2004
  case RRC_HO_STARTED:
    LOG_I(MAC,"RRC handover, Instruct PHY to start the contention-free PRACH and synchronization\n");
2005
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
2006
    stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
2007
    return(PHY_HO_PRACH);
2008

2009 2010 2011
  default:
    break;
  }
2012

2013
#endif
2014 2015

  // Check Contention resolution timer (put in a function later)
2016
  if (UE_mac_inst[module_idP].RA_contention_resolution_timer_active == 1) {
2017

2018
    if (UE_mac_inst[module_idP].radioResourceConfigCommon) {
2019
      rach_ConfigCommon = &UE_mac_inst[module_idP].radioResourceConfigCommon->rach_ConfigCommon;
2020
    } else {
2021
      LOG_E(MAC,"FATAL: radioResourceConfigCommon is NULL!!!\n");
2022
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
2023 2024 2025 2026
      stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
      mac_xface->macphy_exit("");
      //return(RRC_OK);
    }
2027

2028
    LOG_I(MAC,"Frame %d: Contention resolution timer %d/%d\n",frameP,UE_mac_inst[module_idP].RA_contention_resolution_cnt,
2029 2030
          ((1+rach_ConfigCommon->ra_SupervisionInfo.mac_ContentionResolutionTimer)<<3));

2031 2032 2033 2034 2035 2036 2037 2038 2039 2040
    UE_mac_inst[module_idP].RA_contention_resolution_cnt++;

    if (UE_mac_inst[module_idP].RA_contention_resolution_cnt ==
        ((1+rach_ConfigCommon->ra_SupervisionInfo.mac_ContentionResolutionTimer)<<3)) {
      UE_mac_inst[module_idP].RA_active = 0;
      UE_mac_inst[module_idP].RA_contention_resolution_timer_active = 0;
      // Signal PHY to quit RA procedure
      LOG_E(MAC,"Module id %u Contention resolution timer expired, RA failed\n", module_idP);
      mac_xface->ra_failed(module_idP,0,eNB_indexP);
    }
2041 2042 2043
  }


2044
  // Get RLC status info and update Bj for all lcids that are active
fnabet's avatar
fnabet committed
2045
  for (lcid=DCCH; lcid < MAX_NUM_LCID; lcid++ ) {
2046
    if (UE_mac_inst[module_idP].logicalChannelConfig[lcid]) {
2047 2048 2049 2050 2051 2052 2053 2054 2055 2056
      // meausre the Bj
      if ((directionP == SF_UL)&& (UE_mac_inst[module_idP].scheduling_info.Bj[lcid] >= 0)) {
        if (UE_mac_inst[module_idP].logicalChannelConfig[lcid]->ul_SpecificParameters) {
          bucketsizeduration = UE_mac_inst[module_idP].logicalChannelConfig[lcid]->ul_SpecificParameters->prioritisedBitRate * TTI;
          bucketsizeduration_max = get_ms_bucketsizeduration(UE_mac_inst[module_idP].logicalChannelConfig[lcid]->ul_SpecificParameters->bucketSizeDuration);
        } else {
          LOG_E(MAC,"[UE %d] lcid %d, NULL ul_SpecificParameters\n",module_idP,lcid);
          mac_xface->macphy_exit("");
        }

2057
        if ( UE_mac_inst[module_idP].scheduling_info.Bj[lcid] > bucketsizeduration_max ) {
2058
          UE_mac_inst[module_idP].scheduling_info.Bj[lcid] = bucketsizeduration_max;
2059
        } else {
2060
          UE_mac_inst[module_idP].scheduling_info.Bj[lcid] = bucketsizeduration;
2061
        }
2062 2063
      }

2064
      /*
calvin wang's avatar
calvin wang committed
2065 2066 2067 2068
      if (lcid == DCCH) {    
        LOG_D(MAC,"[UE %d][SR] Frame %d subframe %d Pending data for SRB1=%d for LCGID %d \n",                  
        module_idP, frameP,subframeP,UE_mac_inst[module_idP].scheduling_info.BSR[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]],                  
        UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]);
2069
      }
2070
      */
2071
    }
2072
  }
2073

2074
  // Call BSR procedure as described in Section 5.4.5 in 36.321
GabrirelCouturier's avatar
GabrirelCouturier committed
2075

2076 2077 2078 2079 2080 2081
  // First check ReTxBSR Timer because it is always configured
  // Decrement ReTxBSR Timer if it is running and not null
  if ((UE_mac_inst[module_idP].scheduling_info.retxBSR_SF != MAC_UE_BSR_TIMER_NOT_RUNNING)
          && (UE_mac_inst[module_idP].scheduling_info.retxBSR_SF != 0)){
      UE_mac_inst[module_idP].scheduling_info.retxBSR_SF --;
  }
GabrirelCouturier's avatar
GabrirelCouturier committed
2082

2083 2084 2085 2086
  // Decrement Periodic Timer if it is running and not null
  if ((UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF != MAC_UE_BSR_TIMER_NOT_RUNNING)
            && (UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF != 0)){
        UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF--;
2087
    }
GabrirelCouturier's avatar
GabrirelCouturier committed
2088

2089 2090 2091 2092 2093 2094 2095 2096 2097
  //Check whether Regular BSR is triggered
  if (update_bsr(module_idP,frameP, subframeP,eNB_indexP) == TRUE) {
  // call SR procedure to generate pending SR and BSR for next PUCCH/PUSCH TxOp.  This should implement the procedures
  // outlined in Sections 5.4.4 an 5.4.5 of 36.321
    UE_mac_inst[module_idP].scheduling_info.SR_pending= 1;
    // Regular BSR trigger
    UE_mac_inst[module_idP].BSR_reporting_active |= BSR_TRIGGER_REGULAR;
    LOG_D(MAC,"[UE %d][BSR] Regular BSR Triggered Frame %d subframe %d SR for PUSCH is pending\n",
          module_idP, frameP,subframeP);
GabrirelCouturier's avatar
GabrirelCouturier committed
2098 2099
  }

2100
  // UE has no valid phy config dedicated ||  no valid/released  SR
2101
  if ((UE_mac_inst[module_idP].physicalConfigDedicated == NULL)) {
2102 2103 2104 2105
    // cancel all pending SRs
    UE_mac_inst[module_idP].scheduling_info.SR_pending=0;
    UE_mac_inst[module_idP].ul_active=0;
    LOG_T(MAC,"[UE %d] Release all SRs \n", module_idP);
2106
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
2107 2108
    stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
    return(CONNECTION_OK);
2109 2110
  }

2111
  if ((UE_mac_inst[module_idP].physicalConfigDedicated->schedulingRequestConfig == NULL) ||
2112
      (UE_mac_inst[module_idP].physicalConfigDedicated->schedulingRequestConfig->present == SchedulingRequestConfig_PR_release)) {
2113

2114
    // initiate RA with CRNTI included in msg3 (no contention) as descibed in 36.321 sec 5.1.5
2115

2116 2117 2118 2119
    // cancel all pending SRs
    UE_mac_inst[module_idP].scheduling_info.SR_pending=0;
    UE_mac_inst[module_idP].ul_active=0;
    LOG_T(MAC,"[UE %d] Release all SRs \n", module_idP);
2120 2121 2122
  }

  // Put this in a function
2123
  // Call PHR procedure as described in Section 5.4.6 in 36.321
2124 2125
  if (UE_mac_inst[module_idP].PHR_state == MAC_MainConfig__phr_Config_PR_setup) { // normal operation

2126 2127 2128 2129 2130 2131
    if (UE_mac_inst[module_idP].PHR_reconfigured == 1) { // upon (re)configuration of the power headroom reporting functionality by upper layers
      UE_mac_inst[module_idP].PHR_reporting_active = 1;
      UE_mac_inst[module_idP].PHR_reconfigured = 0;
    } else {
      //LOG_D(MAC,"PHR normal operation %d active %d \n", UE_mac_inst[module_idP].scheduling_info.periodicPHR_SF, UE_mac_inst[module_idP].PHR_reporting_active);
      if ((UE_mac_inst[module_idP].scheduling_info.prohibitPHR_SF <= 0) &&
2132 2133 2134
          ((mac_xface->get_PL(module_idP,0,eNB_indexP) <  UE_mac_inst[module_idP].scheduling_info.PathlossChange_db) ||
           (UE_mac_inst[module_idP].power_backoff_db[eNB_indexP] > UE_mac_inst[module_idP].scheduling_info.PathlossChange_db)))
        // trigger PHR and reset the timer later when the PHR report is sent
2135
      {
2136
        UE_mac_inst[module_idP].PHR_reporting_active = 1;
2137
      } else if (UE_mac_inst[module_idP].PHR_reporting_active ==0 ) {
2138
        UE_mac_inst[module_idP].scheduling_info.prohibitPHR_SF--;
2139
      }
2140

2141
      if (UE_mac_inst[module_idP].scheduling_info.periodicPHR_SF <= 0 )
2142
        // trigger PHR and reset the timer later when the PHR report is sent
2143
      {
2144
        UE_mac_inst[module_idP].PHR_reporting_active = 1;
2145
      } else if (UE_mac_inst[module_idP].PHR_reporting_active == 0 ) {
2146
        UE_mac_inst[module_idP].scheduling_info.periodicPHR_SF--;
2147
      }
2148
    }
2149
  } else {    // release / nothing
2150
    UE_mac_inst[module_idP].PHR_reporting_active = 0; // release PHR
2151
  }
2152

2153
  //If the UE has UL resources allocated for new transmission for this TTI here:
2154
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
2155
  stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
2156 2157 2158 2159 2160
  return(CONNECTION_OK);
}

// to be improved
#ifdef CBA
2161
extern int cba_backoff;
2162 2163
double uniform_rngen(int min, int max)
{
2164 2165 2166 2167
  double random = (double)taus()/((double)0xffffffff);
  return (max - min) * random + min;
}

2168 2169
int cba_access(module_id_t module_idP,frame_t frameP,sub_frame_t subframe, uint8_t eNB_index,uint16_t buflen)
{
2170

2171 2172 2173 2174
  mac_rlc_status_resp_t rlc_status;
  int header_offset=4;
  int rv =0;

2175
  /*
2176 2177 2178 2179 2180
  if (( ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1]>0)&&(UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1]<64))   ||
      ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2]>0)&&(UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2]<64))   ||
      ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3]>0)&&(UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3]<64)) )
      //  && (UE_mac_inst[module_idP].ul_active == 0) // check if the ul is acrtive
      && (UE_mac_inst[module_idP].cba_last_access[0] <= 0) ) { // backoff
2181
      //  LOG_D(MAC,"[UE %d] Frame %d Subframe %d: the current CBA backoff is %d \n", module_idP, frameP, subframe,
2182 2183
      //  UE_mac_inst[module_idP].cba_last_access[0] );

2184
      UE_mac_inst[module_idP].cba_last_access[0]= round(uniform_rngen(1,40));
2185
      LOG_D(MAC,"[UE %d] Frame %d Subframe %d: start a new CBA backoff  %d UL active state %d \n", module_idP, frameP, subframe,
2186 2187
          UE_mac_inst[module_idP].cba_last_access[0], UE_mac_inst[module_idP].ul_active);

2188
      rv=1;
2189 2190 2191 2192 2193 2194 2195 2196
  } else if (( ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1]> 0 ))   ||
      ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2]> 0 ))   ||
      ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3]> 0 )) )
      // && (UE_mac_inst[module_idP].ul_active == 0) // check if the ul is acrtive
      && (UE_mac_inst[module_idP].cba_last_access[0]> 0) ){

      UE_mac_inst[module_idP].cba_last_access[0]-=1;
      LOG_D(MAC,"[UE %d] Frame %d Subframe %d: CBA backoff is decreased by one to %d UL active state %d \n",
2197
          module_idP, frameP, subframe,
2198 2199
          UE_mac_inst[module_idP].cba_last_access[0], UE_mac_inst[module_idP].ul_active);

2200 2201 2202 2203
  } else if (( ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1] == 0 ))   &&
               ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2] == 0 ))   &&
               ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3] ==  0 )) )
             && (UE_mac_inst[module_idP].cba_last_access[0]> 0) ){
2204
    UE_mac_inst[module_idP].cba_last_access[0]-=1;
2205
    }*/
2206

2207
  if ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID0]>0)&&(UE_mac_inst[module_idP].scheduling_info.BSR[LCGID0]<64) ) {
2208
    return 0;
2209
  }
2210

2211 2212
  if ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1] <= 0 ) &&
      (UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2] <= 0 ) &&
2213
      (UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3] <= 0 ) ) {
2214
    return 0;
2215
  }
2216

2217
  if (cba_backoff == 0 ) { // apply probablisitc method
2218
    UE_mac_inst[module_idP].cba_last_access[0]= uniform_rngen(0,1);
2219 2220

    if (uniform_rngen(0,1) > 0.6 ) {
2221
      LOG_I(MAC,"[UE %d] Frame %d Subframe %d: CBA probability-based backoff (%d), UL active state %d \n", module_idP, frameP, subframe,
2222 2223
            cba_backoff,UE_mac_inst[module_idP].ul_active);

2224 2225
      rv=1;
    }
2226 2227
  } else {

2228 2229
    if (UE_mac_inst[module_idP].cba_last_access[0] <= 0) {
      UE_mac_inst[module_idP].cba_last_access[0]= round(uniform_rngen(1,cba_backoff));
2230

2231
      LOG_I(MAC,"[UE %d] Frame %d Subframe %d: start a new CBA backoff  %d/%d UL active state %d \n", module_idP, frameP, subframe,
2232 2233 2234 2235
            UE_mac_inst[module_idP].cba_last_access[0], cba_backoff,UE_mac_inst[module_idP].ul_active);

      rv = 1;
      /*
2236
      rlc_status = mac_rlc_status_ind(module_idP, UE_mac_inst[module_idP].crnti,frameP,ENB_FLAG_NO,MBMS_FLAG_NO, // eNB_index
2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250
      DTCH,
      0);

      if ((
      //  (rlc_status.pdus_in_buffer > 0 )           &&
      // (UE_mac_inst[module_idP].ul_active == 0)  && // check if the ul is acrtive
      (rlc_status.head_sdu_is_segmented  == 0 )          &&
      ((rlc_status.head_sdu_remaining_size_to_send + header_offset ) <= buflen )
      )){
      rv = 1;

      UE_mac_inst[module_idP].cba_last_access[0]= round(uniform_rngen(1,30));
      LOG_D(MAC,"[UE %d] Frame %d Subframe %d: start a new CBA backoff  %d UL active state %d \n", module_idP, frameP, subframe,
      UE_mac_inst[module_idP].cba_last_access[0], UE_mac_inst[module_idP].ul_active);
2251 2252 2253 2254
      */
    } else {
      UE_mac_inst[module_idP].cba_last_access[0]-=1;
      LOG_D(MAC,"[UE %d] Frame %d Subframe %d: wait for backoff to expire (%d) CBA UL active state %d \n",
2255 2256 2257
            module_idP, frameP, subframe,
            UE_mac_inst[module_idP].cba_last_access[0], UE_mac_inst[module_idP].ul_active);
    }
2258
  }
2259

2260 2261 2262
  return rv;
  /*
    if (( ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1]>0)&&(UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1]<64))   ||
2263 2264 2265 2266 2267
    ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2]>0)&&(UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2]<64))   ||
    ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3]>0)&&(UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3]<64)) )
  //  && (UE_mac_inst[module_idP].ul_active == 0) // check if the ul is acrtive
  && (UE_mac_inst[module_idP].cba_last_access[0] <= 0) ) {

2268
      UE_mac_inst[module_idP].cba_last_access[0]= round(uniform_rngen(1,cba_backoff));
2269

2270
      LOG_I(MAC,"[UE %d] Frame %d Subframe %d: start a new CBA backoff  %d/%d UL active state %d \n", module_idP, frameP, subframe,
2271 2272 2273 2274
      UE_mac_inst[module_idP].cba_last_access[0], cba_backoff,UE_mac_inst[module_idP].ul_active);

      rv = 1;

2275
    rlc_status = mac_rlc_status_ind(module_idP, UE_mac_inst[module_idP].crnti,frameP,ENB_FLAG_NO,MBMS_FLAG_NO, // eNB_index
2276 2277 2278
            DTCH,
            0);

2279
    if ((
2280 2281 2282 2283 2284
   // (rlc_status.pdus_in_buffer > 0 )           &&
  // (UE_mac_inst[module_idP].ul_active == 0)  && // check if the ul is acrtive
   (rlc_status.head_sdu_is_segmented  == 0 )          &&
   ((rlc_status.head_sdu_remaining_size_to_send + header_offset ) <= buflen )
   )){
2285
      rv = 1;
2286

2287 2288
      UE_mac_inst[module_idP].cba_last_access[0]= round(uniform_rngen(1,30));
      LOG_D(MAC,"[UE %d] Frame %d Subframe %d: start a new CBA backoff  %d UL active state %d \n", module_idP, frameP, subframe,
2289 2290
      UE_mac_inst[module_idP].cba_last_access[0], UE_mac_inst[module_idP].ul_active);
    } else
2291
      UE_mac_inst[module_idP].cba_last_access[0]= round(uniform_rngen(1,5));
2292

2293 2294

    } else if (( ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1]> 0 ))   ||
2295 2296 2297 2298
     ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2]> 0 ))   ||
     ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3]> 0 )) )
         // && (UE_mac_inst[module_idP].ul_active == 0) // check if the ul is acrtive
         && (UE_mac_inst[module_idP].cba_last_access[0]> 0) )
2299
      {
2300 2301 2302 2303 2304

  UE_mac_inst[module_idP].cba_last_access[0]-=1;
  LOG_D(MAC,"[UE %d] Frame %d Subframe %d: wait for backoff to expire (%d) CBA UL active state %d \n",
        module_idP, frameP, subframe,
        UE_mac_inst[module_idP].cba_last_access[0], UE_mac_inst[module_idP].ul_active);
2305 2306
      }
  }
2307 2308
  */

2309 2310 2311 2312
}
#endif


2313
boolean_t  update_bsr(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP,eNB_index_t eNB_index)
2314
{
2315 2316

  mac_rlc_status_resp_t rlc_status;
2317 2318 2319 2320 2321
  boolean_t bsr_regular_triggered = FALSE;
  uint8_t lcid;
  uint8_t lcgid;
  uint8_t num_lcid_with_data = 0; // for LCID with data only if LCGID is defined
  uint16_t lcgid_buffer_remain[MAX_NUM_LCGID] = {0,0,0,0};
2322
  int32_t lcid_bytes_in_buffer[MAX_NUM_LCID];
2323 2324 2325 2326 2327 2328 2329 2330
  /* Array for ordering LCID with data per decreasing priority order */
  uint8_t lcid_reordered_array[MAX_NUM_LCID]=
  {MAX_NUM_LCID,MAX_NUM_LCID,MAX_NUM_LCID,MAX_NUM_LCID,MAX_NUM_LCID,MAX_NUM_LCID,MAX_NUM_LCID,MAX_NUM_LCID,MAX_NUM_LCID,MAX_NUM_LCID,MAX_NUM_LCID};
  uint8_t pos_next = 0;
  uint8_t highest_priority = 16;
  uint8_t array_index = 0;

  // Reset All BSR Infos
hbilel's avatar
hbilel committed
2331
  lcid_bytes_in_buffer[0] = 0;
2332 2333 2334 2335 2336
  for (lcid=DCCH; lcid < MAX_NUM_LCID; lcid++)
  {
	  // Reset transmission status
	  lcid_bytes_in_buffer[lcid] = 0;
	  UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid]=LCID_EMPTY;
2337
  }
2338

hbilel's avatar
hbilel committed
2339
  for (lcgid=0; lcgid < MAX_NUM_LCGID; lcgid++)
2340 2341 2342 2343
  {
	  // Reset Buffer Info
	  UE_mac_inst[module_idP].scheduling_info.BSR[lcgid]=0;
	  UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcgid]=0;
2344
  }
2345

2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366
  //Get Buffer Occupancy and fill lcid_reordered_array
  for (lcid=DCCH; lcid < MAX_NUM_LCID; lcid++)
  {
	  if (UE_mac_inst[module_idP].logicalChannelConfig[lcid])
	  {
		  	lcgid = UE_mac_inst[module_idP].scheduling_info.LCGID[lcid];

		  	// Store already available data to transmit per Group
		  	if (lcgid < MAX_NUM_LCGID)
		  	{
			  	lcgid_buffer_remain[lcgid] += UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid];
		  	}

		    rlc_status = mac_rlc_status_ind(module_idP, UE_mac_inst[module_idP].crnti,eNB_index,frameP,ENB_FLAG_NO,MBMS_FLAG_NO,
		                                    lcid,
		                                    0);

		    lcid_bytes_in_buffer[lcid] = rlc_status.bytes_in_buffer;

		    if (rlc_status.bytes_in_buffer > 0)
		    {
hbilel's avatar
hbilel committed
2367 2368
		          LOG_D(MAC,"[UE %d] PDCCH Tick : LCID%d LCGID%d has data to transmit =%d bytes at frame %d subframe %d\n",
		                              module_idP, lcid,lcgid,rlc_status.bytes_in_buffer,frameP,subframeP);
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405

		         UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] = LCID_NOT_EMPTY;
		         //Update BSR_bytes and position in lcid_reordered_array only if Group is defined
		         if (lcgid < MAX_NUM_LCGID)
		         {
		        	 num_lcid_with_data ++;
			         // sum lcid buffer which has same lcgid
			         UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcgid] += rlc_status.bytes_in_buffer;

			         //Fill in the array
			         array_index = 0;
			         do
					{
			        	 if (UE_mac_inst[module_idP].logicalChannelConfig[lcid]->ul_SpecificParameters->priority <= highest_priority)
			        	 {
			        		 //Insert if priority is higher or equal (lower or equal in value)
			        		 for (pos_next=num_lcid_with_data-1; pos_next > array_index; pos_next--)
			        		 {
			        			 lcid_reordered_array[pos_next] = lcid_reordered_array[pos_next - 1];

			        		 }
			        		 lcid_reordered_array[array_index] = lcid;
			        		 break;

			        	 }
			        	 array_index ++;
					}
			         while ((array_index < num_lcid_with_data) && (array_index < MAX_NUM_LCID));
		         }
		    }
	  }

  }

  // Check whether a regular BSR can be triggered according to the first cases in 36.321
  if (num_lcid_with_data)
  {
hbilel's avatar
hbilel committed
2406 2407 2408
          LOG_D(MAC,"[UE %d] PDCCH Tick at frame %d subframe %d: NumLCID with data=%d Reordered LCID0=%d LCID1=%d LCID2=%d\n",
                            module_idP, frameP, subframeP,num_lcid_with_data,lcid_reordered_array[0],lcid_reordered_array[1],lcid_reordered_array[2]);

2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422
	  for (array_index=0; array_index < num_lcid_with_data; array_index++)
	  {
		  lcid = lcid_reordered_array[array_index];
	      /* UL data, for a logical channel which belongs to a LCG, becomes available for transmission in the RLC entity
	         either the data belongs to a logical channel with higher priority than the priorities of the logical channels
	         which belong to any LCG and for which data is already available for transmission
	      */
		  if ((UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid] == 0)
			/* or there is no data available for any of the logical channels which belong to a LCG */
			||(lcgid_buffer_remain[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]] == 0)
			)
		  {
			  bsr_regular_triggered = TRUE;

hbilel's avatar
hbilel committed
2423 2424
		      LOG_D(MAC,"[UE %d] PDCCH Tick : MAC BSR Triggered LCID%d LCGID%d data become available at frame %d subframe %d\n",
		                      module_idP, lcid,UE_mac_inst[module_idP].scheduling_info.LCGID[lcid],frameP, subframeP);
2425 2426 2427 2428 2429 2430 2431 2432 2433 2434

			  break;
		  }
	  }

	  // Trigger Regular BSR if ReTxBSR Timer has expired and UE has data for transmission
	  if (UE_mac_inst[module_idP].scheduling_info.retxBSR_SF == 0)
	  {
		  bsr_regular_triggered = TRUE;

hbilel's avatar
hbilel committed
2435 2436 2437 2438
		  if ((UE_mac_inst[module_idP].BSR_reporting_active & BSR_TRIGGER_REGULAR) == 0) {
		        LOG_I(MAC,"[UE %d] PDCCH Tick : MAC BSR Triggered ReTxBSR Timer expiry at frame %d subframe %d\n",
		                          module_idP, frameP, subframeP);
		  }
2439 2440 2441 2442 2443 2444 2445 2446

	  }
  }

  //Store Buffer Occupancy in remain buffers for next TTI
  for (lcid=DCCH; lcid < MAX_NUM_LCID; lcid++)
  {
	  UE_mac_inst[module_idP].scheduling_info.LCID_buffer_remain[lcid] = lcid_bytes_in_buffer[lcid];
2447
  }
2448

2449
  return bsr_regular_triggered;
2450 2451
}

fnabet's avatar
fnabet committed
2452
uint8_t locate_BsrIndexByBufferSize (const uint32_t *table, int size, int value)
2453
{
2454

2455
  uint8_t ju, jm, jl;
2456 2457
  int ascend;

2458 2459 2460
  DevAssert( size > 0 );
  DevAssert( size <= 256 );

2461 2462 2463
  if (value == 0) {
    return 0;  //elseif (value > 150000) return 63;
  }
2464

2465 2466
  jl = 0;        // lower bound
  ju = size - 1; // upper bound
2467 2468 2469
  ascend = (table[ju] >= table[jl]) ? 1 : 0; // determine the order of the the table:  1 if ascending order of table, 0 otherwise

  while (ju-jl > 1) { //If we are not yet done,
2470 2471
    jm = (ju+jl) >> 1; //compute a midpoint,

2472
    if ((value >= table[jm]) == ascend) {
2473
      jl=jm; // replace the lower limit
2474
    } else {
2475
      ju=jm; //replace the upper limit
2476
    }
2477 2478

    LOG_T(MAC,"[UE] searching BSR index %d for (BSR TABLE %d < value %d)\n", jm, table[jm], value);
2479
  }
2480

2481 2482 2483 2484 2485
  if (value == table[jl]) {
    return jl;
  } else                    {
    return jl+1;  //equally  ju
  }
2486 2487 2488

}

2489 2490
int get_sf_periodicBSRTimer(uint8_t sf_offset)
{
2491 2492 2493 2494 2495

  switch (sf_offset) {
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf5:
    return 5;
    break;
2496

2497 2498 2499
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf10:
    return 10;
    break;
2500

2501 2502 2503
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf16:
    return 16;
    break;
2504

2505 2506 2507
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf20:
    return 20;
    break;
2508

2509 2510 2511
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf32:
    return 32;
    break;
2512

2513 2514 2515
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf40:
    return 40;
    break;
2516

2517 2518 2519
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf64:
    return 64;
    break;
2520

2521 2522 2523
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf80:
    return 80;
    break;
2524

2525 2526 2527
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf128:
    return 128;
    break;
2528

2529 2530 2531
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf160:
    return 160;
    break;
2532

2533 2534 2535
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf320:
    return 320;
    break;
2536

2537 2538 2539
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf640:
    return 640;
    break;
2540

2541 2542 2543
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf1280:
    return 1280;
    break;
2544

2545 2546 2547
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf2560:
    return 2560;
    break;
2548

2549 2550
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_infinity:
  default:
calvin wang's avatar
calvin wang committed
2551
    return 0xFFFF;
2552 2553 2554 2555
    break;
  }
}

2556 2557
int get_sf_retxBSRTimer(uint8_t sf_offset)
{
2558 2559 2560 2561 2562

  switch (sf_offset) {
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf320:
    return 320;
    break;
2563

2564 2565 2566
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf640:
    return 640;
    break;
2567

2568 2569 2570
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf1280:
    return 1280;
    break;
2571

2572 2573 2574
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf2560:
    return 2560;
    break;
2575

2576 2577 2578
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf5120:
    return 5120;
    break;
2579

2580 2581 2582
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf10240:
    return 10240;
    break;
2583

2584 2585 2586 2587 2588
  default:
    return -1;
    break;
  }
}
2589 2590
int get_ms_bucketsizeduration(uint8_t bucketsizeduration)
{
2591 2592 2593 2594 2595

  switch (bucketsizeduration) {
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms50:
    return 50;
    break;
2596

2597 2598 2599
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms100:
    return 100;
    break;
2600

2601 2602 2603
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms150:
    return 150;
    break;
2604

2605 2606 2607
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms300:
    return 300;
    break;
2608

2609 2610 2611
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms500:
    return 500;
    break;
2612

2613 2614 2615
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms1000:
    return 1000;
    break;
2616

2617 2618 2619 2620 2621 2622
  default:
    return 0;
    break;
  }
}

2623 2624
void update_phr(module_id_t module_idP,int CC_id)
{
Raymond Knopp's avatar
 
Raymond Knopp committed
2625 2626 2627 2628 2629 2630

  if (CC_id>0) {
    LOG_E(MAC,"Transmission on secondary CCs is not supported yet\n");
    mac_xface->macphy_exit("MAC FATAL  CC_id>0");
    return;
  }
2631 2632 2633 2634 2635

  UE_mac_inst[module_idP].PHR_reporting_active =0;
  UE_mac_inst[module_idP].scheduling_info.periodicPHR_SF =  get_sf_perioidicPHR_Timer(UE_mac_inst[module_idP].scheduling_info.periodicPHR_Timer);
  UE_mac_inst[module_idP].scheduling_info.prohibitPHR_SF =  get_sf_prohibitPHR_Timer(UE_mac_inst[module_idP].scheduling_info.prohibitPHR_Timer);
  // LOG_D(MAC,"phr %d %d\n ",UE_mac_inst[module_idP].scheduling_info.periodicPHR_SF, UE_mac_inst[module_idP].scheduling_info.prohibitPHR_SF);
2636
}
2637 2638
uint8_t get_phr_mapping (module_id_t module_idP, int CC_id, uint8_t eNB_index)
{
2639

Raymond Knopp's avatar
 
Raymond Knopp committed
2640 2641 2642
  if (CC_id>0) {
    LOG_E(MAC,"Transmission on secondary CCs is not supported yet\n");
    mac_xface->macphy_exit("MAC FATAL  CC_id>0");
2643
    return 0; // not reached
Raymond Knopp's avatar
 
Raymond Knopp committed
2644
  }
2645

2646 2647
  //power headroom reporting range is from -23 ...+40 dB, as described in 36313
  //note: mac_xface->get_Po_NOMINAL_PUSCH(module_idP) is float
2648
  if (mac_xface->get_PHR(module_idP,CC_id,eNB_index) < -23) {
2649
    return 0;
2650
  } else if (mac_xface->get_PHR(module_idP,CC_id,eNB_index) >= 40) {
2651
    return 63;
2652
  } else { // -23 to 40
Raymond Knopp's avatar
 
Raymond Knopp committed
2653
    return  (uint8_t) mac_xface->get_PHR(module_idP,CC_id,eNB_index) + PHR_MAPPING_OFFSET;
2654

2655
  }
2656
}
2657 2658
int get_sf_perioidicPHR_Timer(uint8_t perioidicPHR_Timer)
{
2659 2660 2661 2662
  return (perioidicPHR_Timer+1)*10;
}


2663 2664
int get_sf_prohibitPHR_Timer(uint8_t prohibitPHR_Timer)
{
2665 2666 2667
  return (prohibitPHR_Timer)*10;
}

2668 2669 2670
int get_db_dl_PathlossChange(uint8_t dl_PathlossChange)
{
  switch (dl_PathlossChange) {
2671 2672 2673
  case MAC_MainConfig__phr_Config__setup__dl_PathlossChange_dB1:
    return 1;
    break;
2674

2675 2676 2677
  case MAC_MainConfig__phr_Config__setup__dl_PathlossChange_dB3:
    return 3;
    break;
2678

2679 2680 2681
  case MAC_MainConfig__phr_Config__setup__dl_PathlossChange_dB6:
    return 6;
    break;
2682

2683 2684 2685 2686 2687 2688
  case MAC_MainConfig__phr_Config__setup__dl_PathlossChange_infinity:
  default:
    return -1;
    break;
  }
}