ue_procedures.c 83.6 KB
Newer Older
1
/*******************************************************************************
2 3
    OpenAirInterface
    Copyright(c) 1999 - 2014 Eurecom
4

5 6 7 8
    OpenAirInterface is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
9 10


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

16 17 18 19
    You should have received a copy of the GNU General Public License
    along with OpenAirInterface.The full GNU General Public License is
    included in this distribution in the file called "COPYING". If not,
    see <http://www.gnu.org/licenses/>.
20 21

  Contact Information
22 23
  OpenAirInterface Admin: openair_admin@eurecom.fr
  OpenAirInterface Tech : openair_tech@eurecom.fr
24
  OpenAirInterface Dev  : openair4g-devel@lists.eurecom.fr
25

ghaddab's avatar
ghaddab committed
26
  Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
27 28

*******************************************************************************/
29 30

/*! \file ue_procedures.c
31
 * \brief procedures related to UE
32 33 34
 * \author  Navid Nikaein and Raymond Knopp
 * \date 2010 - 2014
 * \version 1
35 36
 * \email: navid.nikaein@eurecom.fr
 * @ingroup _mac
37

38
 */
39

40 41 42 43
#ifdef EXMIMO
#include <pthread.h>
#endif

44 45
#include "extern.h"
#include "defs.h"
46
#include "proto.h"
47
#ifdef PHY_EMUL
Cedric Roux's avatar
Cedric Roux committed
48
# include "SIMULATION/PHY_EMULATION/impl_defs.h"
49
#else
Cedric Roux's avatar
Cedric Roux committed
50 51
# include "SCHED/defs.h"
# include "PHY/impl_defs_top.h"
52 53 54 55
#endif
#include "PHY_INTERFACE/defs.h"
#include "PHY_INTERFACE/extern.h"
#include "COMMON/mac_rrc_primitives.h"
Cedric Roux's avatar
Cedric Roux committed
56 57

#include "RRC/L2_INTERFACE/openair_rrc_L2_interface.h"
58 59 60
#include "RRC/LITE/extern.h"
#include "UTIL/LOG/log.h"
#include "UTIL/LOG/vcd_signal_dumper.h"
Cedric Roux's avatar
Cedric Roux committed
61
#include "UTIL/OPT/opt.h"
62 63
#include "OCG.h"
#include "OCG_extern.h"
Cedric Roux's avatar
Cedric Roux committed
64

65
#ifdef PHY_EMUL
Cedric Roux's avatar
Cedric Roux committed
66
# include "SIMULATION/simulation_defs.h"
67
#endif
68
#include "pdcp.h"
69

70 71 72 73
#if defined(ENABLE_ITTI)
# include "intertask_interface.h"
#endif

74 75
#include "assertions.h"

76 77
#include "SIMULATION/TOOLS/defs.h" // for taus

78
#define DEBUG_HEADER_PARSING 1
79
#define ENABLE_MAC_PAYLOAD_DEBUG 1
80 81 82 83 84

/*
#ifndef USER_MODE
#define msg debug_msg
#endif
85
 */
86
mapping BSR_names[] = {
87 88 89 90 91 92
  {"NONE", 0},
  {"SHORT BSR", 1},
  {"TRUNCATED BSR", 2},
  {"LONG BSR", 3},
  {"PADDING BSR", 4},
  {NULL, -1}
93 94 95
};


96 97
void ue_init_mac(module_id_t module_idP)
{
98 99
  int i;
  // default values as deined in 36.331 sec 9.2.2
100 101 102 103 104 105 106 107 108 109 110 111 112
  LOG_I(MAC,"[UE%d] Applying default macMainConfig\n",module_idP);
  //UE_mac_inst[module_idP].scheduling_info.macConfig=NULL;
  UE_mac_inst[module_idP].scheduling_info.retxBSR_Timer= MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf2560;
  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;
113 114
  UE_mac_inst[module_idP].scheduling_info.extendedBSR_Sizes_r10=0;
  UE_mac_inst[module_idP].scheduling_info.extendedPHR_r10=0;
115 116 117 118
  UE_mac_inst[module_idP].scheduling_info.drx_config=NULL;
  UE_mac_inst[module_idP].scheduling_info.phr_config=NULL;
  UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF  =  get_sf_periodicBSRTimer(UE_mac_inst[module_idP].scheduling_info.periodicBSR_Timer);
  UE_mac_inst[module_idP].scheduling_info.retxBSR_SF     =  get_sf_retxBSRTimer(UE_mac_inst[module_idP].scheduling_info.retxBSR_Timer);
119
  UE_mac_inst[module_idP].BSR_reporting_active = 0;
120 121 122
  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);
123
  UE_mac_inst[module_idP].PHR_reporting_active = 0;
124 125

  for (i=0; i < MAX_NUM_LCID; i++) {
Raymond Knopp's avatar
 
Raymond Knopp committed
126 127
    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;
128 129
    UE_mac_inst[module_idP].scheduling_info.bucket_size[i]=-1;

130
    if (i < DTCH) { // initilize all control channels lcgid to 0
131
      UE_mac_inst[module_idP].scheduling_info.LCGID[i]=0;
132
    } else { // initialize all the data channels lcgid to 1
133
      UE_mac_inst[module_idP].scheduling_info.LCGID[i]=1;
134
    }
135

136
    UE_mac_inst[module_idP].scheduling_info.LCID_status[i]=LCID_EMPTY;
137
  }
138

139
#ifdef CBA
140

141
  for (i=0; i <NUM_MAX_CBA_GROUP; i++) {
142
    UE_mac_inst[module_idP].cba_last_access[i]= round(uniform_rngen(1,30));
143
  }
144 145

#endif
146 147
}

Raymond Knopp's avatar
 
Raymond Knopp committed
148

149
unsigned char *parse_header(unsigned char *mac_header,
150 151 152 153 154 155 156
                            unsigned char *num_ce,
                            unsigned char *num_sdu,
                            unsigned char *rx_ces,
                            unsigned char *rx_lcids,
                            unsigned short *rx_lengths,
                            unsigned short tb_length)
{
157 158 159 160 161 162 163

  unsigned char not_done=1,num_ces=0,num_sdus=0,lcid, num_sdu_cnt;
  unsigned char *mac_header_ptr = mac_header;
  unsigned short length,ce_len=0;

  while (not_done==1) {

164 165 166 167 168 169 170 171 172 173 174 175 176
    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;

177
        for (num_sdu_cnt=0; num_sdu_cnt < num_sdus ; num_sdu_cnt++) {
178
          length -= rx_lengths[num_sdu_cnt];
179
        }
180 181 182 183
      } 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;
184
#ifdef DEBUG_HEADER_PARSING
185
          LOG_D(MAC,"[UE] parse long sdu, size %x \n",length);
186
#endif
187

188 189 190 191 192 193
        }  else { //if (((SCH_SUBHEADER_SHORT *)mac_header_ptr)->F == 0) {
          length = ((SCH_SUBHEADER_SHORT *)mac_header_ptr)->L;
          mac_header_ptr += 2;
        }
      }

194
#ifdef DEBUG_HEADER_PARSING
195 196
      LOG_D(MAC,"[UE] sdu %d lcid %d length %d (offset now %d)\n",
            num_sdus,lcid,length,mac_header_ptr-mac_header);
197
#endif
198 199 200 201 202 203 204 205 206 207 208
      rx_lcids[num_sdus] = lcid;
      rx_lengths[num_sdus] = length;
      num_sdus++;
    } else { // This is a control element subheader
      if (lcid == SHORT_PADDING) {
        mac_header_ptr++;
      } else {
        rx_ces[num_ces] = lcid;
        num_ces++;
        mac_header_ptr ++;

209
        if (lcid==TIMING_ADV_CMD) {
210
          ce_len++;
211
        } else if (lcid==UE_CONT_RES) {
212
          ce_len+=6;
213
        }
214
      }
215

216
#ifdef DEBUG_HEADER_PARSING
217
      LOG_D(MAC,"[UE] ce %d lcid %d (offset now %d)\n",num_ces,lcid,mac_header_ptr-mac_header);
218
#endif
219
    }
220
  }
221

222 223 224 225 226 227
  *num_ce = num_ces;
  *num_sdu = num_sdus;

  return(mac_header_ptr);
}

228 229
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)
{
230 231 232

  // 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
233 234 235
  int MGRP       = 0; // measurement gap repetition period in ms
  int gapOffset  = -1;
  int T          = 0;
236

237
  DevCheck(module_idP < (int)NB_UE_INST, module_idP, NB_UE_INST, 0);
238

Raymond Knopp's avatar
 
Raymond Knopp committed
239 240 241
  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");
242
    return 0;
Raymond Knopp's avatar
 
Raymond Knopp committed
243 244
  }

245
  // determin the measurement gap
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
  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);
    }
266
  }
267 268

  if ((UE_mac_inst[module_idP].physicalConfigDedicated != NULL) &&
269
      (UE_mac_inst[module_idP].scheduling_info.SR_pending==1) &&
270
      (UE_mac_inst[module_idP].scheduling_info.SR_COUNTER <
271 272
       (1<<(2+UE_mac_inst[module_idP].physicalConfigDedicated->schedulingRequestConfig->choice.setup.dsr_TransMax)))
     ) {
273
    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",
274
          module_idP,rnti,frameP,subframe,
275 276 277 278
          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);

279
    UE_mac_inst[module_idP].scheduling_info.SR_COUNTER++;
280

281 282 283 284
    // 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;
285
    } else {
286
      UE_mac_inst[module_idP].scheduling_info.sr_ProhibitTimer_Running=0;
287
    }
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302

    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
    UE_mac_inst[module_idP].scheduling_info.SR_pending=0;
    UE_mac_inst[module_idP].scheduling_info.SR_COUNTER=0;
303 304 305 306 307 308
    // release all pucch resource
    UE_mac_inst[module_idP].physicalConfigDedicated = NULL;
    UE_mac_inst[module_idP].ul_active=0;
    UE_mac_inst[module_idP].BSR_reporting_active=0;
    
    LOG_T(MAC,"[UE %d] Release all SRs \n", module_idP);
309
    return(0);
310 311 312
  }
}

313 314
//------------------------------------------------------------------------------
void
315 316 317 318 319 320 321 322 323 324
ue_send_sdu(
  module_id_t module_idP,
  uint8_t CC_id,
  frame_t frameP,
  uint8_t* sdu,
  uint16_t sdu_len,
  uint8_t eNB_index
)
//------------------------------------------------------------------------------
{
325 326 327 328 329 330

  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;

331
  start_meas(&UE_mac_inst[module_idP].rx_dlsch_sdu);
332
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_SDU, VCD_FUNCTION_IN);
333 334 335

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

336
  if (opt_enabled) {
337
    trace_pdu(1, sdu, sdu_len, module_idP, 3, UE_mac_inst[module_idP].crnti,
navid's avatar
navid committed
338 339 340
              UE_mac_inst[module_idP].subframe, 0, 0); 
    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);
341 342 343 344 345
  }

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

#ifdef DEBUG_HEADER_PARSING
346
  LOG_D(MAC,"[UE %d] ue_send_sdu : Frame %d eNB_index %d : num_ce %d num_sdu %d\n",module_idP,
347
        frameP,eNB_index,num_ce,num_sdu);
348 349 350 351
#endif

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

353
  for (i=0; i<32; i++) {
354
    LOG_T(MAC,"%x.",sdu[i]);
355
  }
356

357
  LOG_T(MAC,"\n");
358 359
#endif

360 361 362 363
  for (i=0; i<num_ce; i++) {
    //    printf("ce %d : %d\n",i,rx_ces[i]);
    switch (rx_ces[i]) {
    case UE_CONT_RES:
364

365
      LOG_I(MAC,"[UE %d][RAPROC] Frame %d : received contention resolution msg: %x.%x.%x.%x.%x.%x, Terminating RA procedure\n",
366
            module_idP,frameP,payload_ptr[0],payload_ptr[1],payload_ptr[2],payload_ptr[3],payload_ptr[4],payload_ptr[5]);
367 368 369 370 371 372 373 374 375 376 377 378 379

      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);
380
            UE_mac_inst[module_idP].RA_contention_resolution_timer_active = 0;
381
            VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_SDU, VCD_FUNCTION_OUT);
382 383 384 385 386 387 388 389 390 391 392 393
            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:
394
#ifdef DEBUG_HEADER_PARSING
395
      LOG_D(MAC,"[UE] CE %d : UE Timing Advance : %d\n",i,payload_ptr[0]);
396
#endif
397 398 399 400 401
      mac_xface->process_timing_advance(module_idP,CC_id,payload_ptr[0]);
      payload_ptr++;
      break;

    case DRX_CMD:
402
#ifdef DEBUG_HEADER_PARSING
403
      LOG_D(MAC,"[UE] CE %d : UE DRX :",i);
404
#endif
405 406 407
      payload_ptr++;
      break;
    }
408
  }
409 410

  for (i=0; i<num_sdu; i++) {
411
#ifdef DEBUG_HEADER_PARSING
412
    LOG_D(MAC,"[UE] SDU %d : LCID %d, length %d\n",i,rx_lcids[i],rx_lengths[i]);
413
#endif
414
    
415 416
    if (rx_lcids[i] == CCCH) {

417 418 419 420 421 422
      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]);
423 424

#if defined(ENABLE_MAC_PAYLOAD_DEBUG)
425
      int j;
426

427
      for (j=0; j<rx_lengths[i]; j++) {
428
        LOG_T(MAC,"%x.",(uint8_t)payload_ptr[j]);
429
      }
430 431 432 433

      LOG_T(MAC,"\n");
#endif
      mac_rrc_data_ind(module_idP,
434
                       CC_id,
435
                       frameP,0, // unknown subframe
436
                       UE_mac_inst[module_idP].crnti,
437
                       CCCH,
438 439 440 441 442
                       (uint8_t*)payload_ptr,
                       rx_lengths[i],
                       ENB_FLAG_NO,
                       eNB_index,
                       0);
443

444
    } else if ((rx_lcids[i] == DCCH) || (rx_lcids[i] == DCCH1)) {
445
      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]);
446 447
      mac_rlc_data_ind(module_idP,
                       UE_mac_inst[module_idP].crnti,
448
		       eNB_index,
449 450 451
                       frameP,
                       ENB_FLAG_NO,
                       MBMS_FLAG_NO,
452
                       rx_lcids[i],
453 454 455 456
                       (char *)payload_ptr,
                       rx_lengths[i],
                       1,
                       NULL);
457 458 459
 
    } else if ((rx_lcids[i]  < NB_RB_MAX) && (rx_lcids[i] > DCCH1 )) {
      
460
      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]);
461 462

#if defined(ENABLE_MAC_PAYLOAD_DEBUG)
463
      int j;
464 465
      for (j=0;j<rx_lengths[i];j++)
	LOG_T(MAC,"%x.",(unsigned char)payload_ptr[j]);
466
      LOG_T(MAC,"\n");
467
#endif
468
      mac_rlc_data_ind(module_idP,
469
		       UE_mac_inst[module_idP].crnti,
470 471
		       eNB_index,
		       frameP,
472 473 474 475 476 477 478 479 480
		       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);
481 482
    }
    payload_ptr+= rx_lengths[i];
483
  }
484
  
485
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_SDU, VCD_FUNCTION_OUT);
486
  stop_meas(&UE_mac_inst[module_idP].rx_dlsch_sdu);
487 488
}

489 490
void ue_decode_si(module_id_t module_idP,int CC_id,frame_t frameP, uint8_t eNB_index, void *pdu,uint16_t len)
{
491

492
  start_meas(&UE_mac_inst[module_idP].rx_si);
493
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_SI, VCD_FUNCTION_IN);
494

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

497
  mac_rrc_data_ind(module_idP,
498
                   CC_id,
499
                   frameP,0, // unknown subframe
500
                   SI_RNTI,
501 502 503
                   BCCH,
                   (uint8_t *)pdu,
                   len,
504
                   ENB_FLAG_NO,
505 506
                   eNB_index,
                   0);
507
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_SI, VCD_FUNCTION_OUT);
508
  stop_meas(&UE_mac_inst[module_idP].rx_si);
navid's avatar
navid committed
509 510 511 512 513 514 515 516 517 518 519 520 521
  if (opt_enabled == 1) {
    trace_pdu(0,
	      (uint8_t *)pdu,
	      len,
	      module_idP,
	      4,
	      0xffff,
	      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);
  }
522 523 524 525
}

#ifdef Rel10
unsigned char *parse_mch_header(unsigned char *mac_header,
526 527 528 529 530
                                unsigned char *num_sdu,
                                unsigned char *rx_lcids,
                                unsigned short *rx_lengths,
                                unsigned short tb_length)
{
531 532 533
  unsigned char not_done=1, num_sdus=0, lcid, i;
  unsigned char *mac_header_ptr = mac_header;
  unsigned short length;
534

535
  while (not_done == 1) {
536 537 538 539 540 541 542 543 544 545 546
    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);

547
        for (i=0; i<num_sdus; i++) {
548
          length -= rx_lengths[i];
549
        }
550 551 552 553 554 555 556 557 558
      } 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;
        }
559
      }
560 561 562 563 564 565 566 567

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

570 571 572 573 574
  *num_sdu = num_sdus;
  return(mac_header_ptr);
}

// this function is for sending mch_sdu from phy to mac
575 576
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)
{
577 578

  unsigned char num_sdu, i, *payload_ptr;
579
  unsigned char rx_lcids[NB_RB_MAX];
580 581
  unsigned short rx_lengths[NB_RB_MAX];

582
  start_meas(&UE_mac_inst[module_idP].rx_mch_sdu);
583
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_MCH_SDU, VCD_FUNCTION_IN);
584

585
  LOG_D(MAC,"[UE %d] Frame %d : process the mch PDU for sync area %d \n",module_idP,frameP, sync_area);
586 587
  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);
588 589

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

  for (i=0; i<num_sdu; i++) {
593 594 595 596 597 598 599
    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;
600
      }
601 602 603
    } 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,
604
                       CC_id,
605
                       frameP,0, // unknown subframe
606
                       M_RNTI,
607 608 609 610 611 612 613 614
                       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,
615
          UE_mac_inst[module_idP].crnti,
616 617
          eNB_index,
	  frameP,
618 619 620 621 622 623 624
          ENB_FLAG_NO,
          MBMS_FLAG_YES,
          MTCH, /*+ (maxDRB + 3),*/
          (char *)payload_ptr,
          rx_lengths[i],
          1,
          NULL);
625 626

      }
627 628 629 630 631 632 633 634 635
    } 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);
    }
636

637
    payload_ptr += rx_lengths[i];
638 639
  }

640
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_MCH_SDU, VCD_FUNCTION_OUT);
641
  stop_meas(&UE_mac_inst[module_idP].rx_mch_sdu);
642 643
}

644 645
int8_t ue_get_mbsfn_sf_alloction (module_id_t module_idP, uint8_t mbsfn_sync_area, unsigned char eNB_index)
{
646
  // currently there is one-to-one mapping between sf allocation pattern and sync area
647 648
  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 );
649
    return -1;
650
  } else if (UE_mac_inst[module_idP].mbsfn_SubframeConfig[mbsfn_sync_area] != NULL) {
651
    return mbsfn_sync_area;
652
  } else {
653
    LOG_W( MAC, "[UE %"PRIu8"] MBSFN Subframe Config pattern %"PRIu8" not found \n", module_idP, mbsfn_sync_area );
654
    return -1;
655 656
  }
}
657

658 659
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)
{
660

winckel's avatar
winckel committed
661
  int i=0, j=0, ii=0, msi_pos=0, mcch_mcs = - 1;
662
  int mcch_flag=0, mtch_flag=0, msi_flag=0;
663 664
  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
665
  int mch_scheduling_period = -1;
666 667 668

  start_meas(&UE_mac_inst[module_idP].ue_query_mch);

669
  if (UE_mac_inst[module_idP].pmch_Config[0]) {
670
    mch_scheduling_period = 8<<(UE_mac_inst[module_idP].pmch_Config[0]->mch_SchedulingPeriod_r9);
671
  }
672

673
  for (i=0;
674 675 676
       i< UE_mac_inst[module_idP].num_active_mbsfn_area;
       i++ ) {
    // assume, that there is always a mapping
677
    if ((j=ue_get_mbsfn_sf_alloction(module_idP,i,eNB_index)) == -1) {
678
      return -1; // continue;
679
    }
680 681 682 683 684 685

    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);

686 687
    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",
688
          module_idP,frameP, subframe,i,UE_mac_inst[module_idP].num_active_mbsfn_area,
689 690 691
          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);

692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
    // 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:
          if (mac_xface->lte_frame_parms->frame_type == FDD) {
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_FDD_SF1) == MBSFN_FDD_SF1) {
729
              if (msi_pos == 1) {
730
                msi_flag = 1;
731
              }
732 733

              if ( (frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
734
                   ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF1) == MBSFN_FDD_SF1) ) {
735
                mcch_flag = 1;
736
              }
737 738 739 740 741 742 743 744 745 746

              mtch_flag = 1;
            }
          }

          break;

        case 2:
          if (mac_xface->lte_frame_parms->frame_type == FDD) {
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_FDD_SF2) == MBSFN_FDD_SF2) {
747
              if (msi_pos == 2) {
748
                msi_flag = 1;
749
              }
750 751

              if ( (frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
752
                   ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF2) == MBSFN_FDD_SF2) ) {
753
                mcch_flag = 1;
754
              }
755 756 757 758

              mtch_flag = 1;
            }
          }
759

760 761 762 763 764
          break;

        case 3:
          if (mac_xface->lte_frame_parms->frame_type == TDD) { // TDD
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF3) == MBSFN_TDD_SF3) {
765
              if (msi_pos == 1) {
766
                msi_flag = 1;
767
              }
768 769

              if ( (frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
770
                   ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_TDD_SF3) == MBSFN_TDD_SF3) ) {
771
                mcch_flag = 1;
772
              }
773 774 775 776 777

              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) {
778
              if (msi_pos == 3) {
779
                msi_flag = 1;
780
              }
781 782

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
783
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF3) == MBSFN_FDD_SF3) ) {
784
                mcch_flag = 1;
785
              }
786 787 788 789 790 791 792 793 794 795

              mtch_flag = 1;
            }
          }

          break;

        case 4:
          if (mac_xface->lte_frame_parms->frame_type == TDD) {
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF4) == MBSFN_TDD_SF4) {
796
              if (msi_pos == 2) {
797
                msi_flag = 1;
798
              }
799 800

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

              mtch_flag = 1;
            }
          }

          break;

        case 6:
          if (mac_xface->lte_frame_parms->frame_type == FDD) {
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_FDD_SF6) == MBSFN_FDD_SF6) {
814
              if (msi_pos == 4) {
815
                msi_flag = 1;
816
              }
817 818

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
819
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF6) == MBSFN_FDD_SF6) ) {
820
                mcch_flag = 1;
821
              }
822 823 824

              mtch_flag = 1;
            }
825
          }
826 827 828 829 830 831

          break;

        case 7:
          if (mac_xface->lte_frame_parms->frame_type == TDD) { // TDD
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF7) == MBSFN_TDD_SF7) {
832
              if (msi_pos == 3) {
833
                msi_flag = 1;
834
              }
835 836

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

              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) {
845
              if (msi_pos == 5) {
846
                msi_flag = 1;
847
              }
848 849

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
850
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF7) == MBSFN_FDD_SF7) ) {
851
                mcch_flag = 1;
852
              }
853 854 855

              mtch_flag = 1;
            }
856
          }
857 858 859 860 861 862

          break;

        case 8:
          if (mac_xface->lte_frame_parms->frame_type == TDD) { //TDD
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF8) == MBSFN_TDD_SF8) {
863
              if (msi_pos == 4) {
864
                msi_flag = 1;
865
              }
866 867

              if ( (frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
868
                   ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_TDD_SF8) == MBSFN_TDD_SF8) ) {
869
                mcch_flag = 1;
870
              }
871 872 873 874 875

              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) {
876
              if (msi_pos == 6) {
877
                msi_flag = 1;
878
              }
879 880

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
881
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_FDD_SF8) == MBSFN_FDD_SF8) ) {
882
                mcch_flag = 1;
883
              }
884 885 886 887 888 889 890 891 892 893

              mtch_flag = 1;
            }
          }

          break;

        case 9:
          if (mac_xface->lte_frame_parms->frame_type == TDD) {
            if ((UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->subframeAllocation.choice.oneFrame.buf[0] & MBSFN_TDD_SF9) == MBSFN_TDD_SF9) {
894
              if (msi_pos == 5) {
895
                msi_flag = 1;
896
              }
897 898

              if ((frameP % mcch_period == UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.mcch_Offset_r9) &&
899
                  ((UE_mac_inst[module_idP].mbsfn_AreaInfo[i]->mcch_Config_r9.sf_AllocInfo_r9.buf[0] & MBSFN_TDD_SF9) == MBSFN_TDD_SF9) ) {
900
                mcch_flag = 1;
901
              }
902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918

              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
919
      }
920
    }
921
  } // end of for
922

923
  stop_meas(&UE_mac_inst[module_idP].ue_query_mch);
924

925
  if ( (mcch_flag==1)) { // || (msi_flag==1))
926
    *mcch_active=1;
927
  }
928

929 930
  if ( (mcch_flag==1) || ((msi_flag==1) && (UE_mac_inst[module_idP].mcch_status==1)) ) {
    return mcch_mcs;
931
  } else if ((mtch_flag==1) && (UE_mac_inst[module_idP].msi_status==1)) {
932
    return UE_mac_inst[module_idP].pmch_Config[0]->dataMCS_r9;
933
  } else {
934
    return -1;
935
  }
936 937 938 939
}

#endif

940
unsigned char generate_ulsch_header(uint8_t *mac_header,
941 942 943 944 945 946 947 948 949 950 951
                                    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)
{
952 953 954 955 956 957 958

  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
959

960
  for (i=0; i<num_sdus; i++) {
961
    LOG_T(MAC,"[UE] sdu %d : lcid %d length %d",i,sdu_lcids[i],sdu_lengths[i]);
962
  }
963

964 965 966 967 968
  LOG_T(MAC,"\n");
#endif
  ce_ptr = &mac_header_control_elements[0];

  if ((short_padding == 1) || (short_padding == 2)) {
969 970 971 972 973
    mac_header_ptr->R    = 0;
    mac_header_ptr->E    = 0;
    mac_header_ptr->LCID = SHORT_PADDING;
    first_element=1;
    last_size=1;
974
  }
975

976
  if (short_padding == 2) {
977 978 979 980 981 982
    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;
983 984 985
  }

  if (power_headroom) {
986 987 988 989 990 991 992 993 994 995 996 997 998 999
    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));
1000 1001 1002 1003
  }

  if (crnti) {
#ifdef DEBUG_HEADER_PARSING
1004
    LOG_D(MAC,"[UE] CRNTI : %x (first_element %d)\n",*crnti,first_element);
1005
#endif
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020

    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);
1021 1022 1023
  }

  if (truncated_bsr) {
1024 1025 1026
    if (first_element>0) {
      mac_header_ptr->E = 1;
      /*
1027
      printf("last subheader : %x (R%d,E%d,LCID%d)\n",*(unsigned char*)mac_header_ptr,
1028 1029 1030 1031 1032 1033 1034 1035 1036
      ((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;
    }

1037
#ifdef DEBUG_HEADER_PARSING
1038
    LOG_D(MAC,"[UE] Scheduler Truncated BSR Header\n");
1039
#endif
1040 1041 1042 1043 1044 1045 1046
    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);
1047

1048 1049 1050 1051
  } else if (short_bsr) {
    if (first_element>0) {
      mac_header_ptr->E = 1;
      /*
1052
      printf("last subheader : %x (R%d,E%d,LCID%d)\n",*(unsigned char*)mac_header_ptr,
1053 1054 1055 1056 1057 1058 1059 1060 1061
      ((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;
    }

1062
#ifdef DEBUG_HEADER_PARSING
1063
    LOG_D(MAC,"[UE] Scheduler SHORT BSR Header\n");
1064
#endif
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
    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;
      /*
1077
      printf("last subheader : %x (R%d,E%d,LCID%d)\n",*(unsigned char*)mac_header_ptr,
1078 1079 1080 1081 1082 1083 1084 1085 1086
      ((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;
    }

1087
#ifdef DEBUG_HEADER_PARSING
1088
    LOG_D(MAC,"[UE] Scheduler Long BSR Header\n");
1089
#endif
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
    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);
    /* Padding */
    *(ce_ptr + 3) = 0;
    ce_ptr += BSR_LONG_SIZE;

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

1105 1106
  //  printf("last_size %d,mac_header_ptr %p\n",last_size,mac_header_ptr);

1107
  for (i=0; i<num_sdus; i++) {
1108
#ifdef DEBUG_HEADER_PARSING
1109
    LOG_T(MAC,"[UE] sdu subheader %d (lcid %d, %d bytes)\n",i,sdu_lcids[i],sdu_lengths[i]);
1110
#endif
1111 1112 1113

    if ((first_element>0)) {
      mac_header_ptr->E = 1;
1114
#ifdef DEBUG_HEADER_PARSING
1115 1116 1117 1118
      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);
1119
#endif
1120 1121 1122 1123
      mac_header_ptr+=last_size;
      //      printf("last_size %d,mac_header_ptr %p\n",last_size,mac_header_ptr);
    } else {
      first_element=1;
1124

1125 1126 1127 1128 1129 1130 1131 1132 1133
    }

    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;
1134
#ifdef DEBUG_HEADER_PARSING
1135 1136 1137 1138 1139 1140 1141 1142
      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);
1143
#endif
1144 1145 1146 1147 1148 1149 1150 1151 1152
    } 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;
1153
#ifdef DEBUG_HEADER_PARSING
1154
      LOG_D(MAC,"[UE] long sdu\n");
1155
#endif
1156
    }
1157
  }
1158

1159
  if (post_padding>0) {// we have lots of padding at the end of the packet
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170
    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 ++
1171
  }
1172

1173
  if ((ce_ptr-mac_header_control_elements) > 0) {
1174 1175
    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);
1176
  }
1177

1178 1179
#ifdef DEBUG_HEADER_PARSING
  LOG_T(MAC," [UE %d] header : ", crnti);
1180

1181
  for (i=0; i<((unsigned char*)mac_header_ptr - mac_header); i++) {
1182
    LOG_T(MAC,"%2x.",mac_header[i]);
1183
  }
1184

1185 1186 1187 1188 1189 1190
  LOG_T(MAC,"\n");
#endif
  return((unsigned char*)mac_header_ptr - mac_header);

}

1191 1192
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)
{
1193 1194

  mac_rlc_status_resp_t rlc_status;
1195
  uint8_t dcch_header_len=0,dcch1_header_len=0,dtch_header_len=0,dtch_header_len_last=0;
1196
  uint8_t dcch_header_len_tmp=0, dtch_header_len_tmp=0;
1197
  uint8_t bsr_header_len=0, bsr_ce_len=0, bsr_len=0;
1198
  uint8_t phr_header_len=0, phr_ce_len=0,phr_len=0;
1199
  uint8_t lcid=0;
1200 1201 1202 1203 1204
  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;
1205
  BSR_SHORT bsr_short;
1206 1207 1208 1209 1210
  BSR_LONG bsr_long;
  BSR_SHORT *bsr_s=&bsr_short;
  BSR_LONG  *bsr_l=&bsr_long;
  POWER_HEADROOM_CMD phr;
  POWER_HEADROOM_CMD *phr_p=&phr;
1211
  unsigned short short_padding=0, post_padding=0, padding_len=0;
Cedric Roux's avatar
Cedric Roux committed
1212
  int lcgid;
1213 1214
  int j; // used for padding
  // Compute header length
1215 1216
  int all_pdu_len;
  
Raymond Knopp's avatar
 
Raymond Knopp committed
1217 1218 1219 1220 1221 1222
  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;
  }

1223
  start_meas(&UE_mac_inst[module_idP].tx_ulsch_sdu);
1224
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GET_SDU, VCD_FUNCTION_IN);
1225

Cedric Roux's avatar
Cedric Roux committed
1226
#ifdef CBA
1227 1228 1229

  if (*access_mode==CBA_ACCESS) {
    LOG_D(MAC,"[UE %d] frameP %d subframe %d try CBA transmission\n",
1230
          module_idP, frameP, subframe);
1231 1232 1233 1234

    //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;
1235
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GET_SDU, VCD_FUNCTION_OUT);
1236 1237 1238 1239
      return;
    }

    LOG_I(MAC,"[UE %d] frameP %d subframe %d CBA transmission oppurtunity, tbs %d\n",
1240
          module_idP, frameP, subframe,buflen);
1241
  }
1242

1243 1244 1245 1246 1247 1248 1249
#endif
  dcch_header_len=2;//sizeof(SCH_SUBHEADER_SHORT);
  dcch1_header_len=2;//sizeof(SCH_SUBHEADER_SHORT);
  // hypo length,in case of long header skip the padding byte
  dtch_header_len=(buflen > 128 ) ? 3 : 2 ; //sizeof(SCH_SUBHEADER_LONG)-1 : sizeof(SCH_SUBHEADER_SHORT);
  bsr_header_len = 1;//sizeof(SCH_SUBHEADER_FIXED);
  phr_header_len = 1;//sizeof(SCH_SUBHEADER_FIXED);
1250

1251 1252
  bsr_ce_len = get_bsr_len (module_idP, eNB_index, frameP, buflen);
  // retxBSR-Timer expires or periodicBSR-Timer expires and Regular BSR trigger
1253
  if ((bsr_ce_len > 0 ) && (UE_mac_inst[module_idP].BSR_reporting_active > 0)) {
1254 1255
    bsr_len = bsr_ce_len + bsr_header_len;
    LOG_D(MAC,"[UE %d] header size info: dcch %d, dcch1 %d, dtch %d, bsr (ce%d,hdr%d) buff_len %d\n",
1256
          module_idP, dcch_header_len,dcch1_header_len,dtch_header_len, bsr_ce_len, bsr_header_len, buflen);
1257 1258 1259 1260 1261 1262
  } else {
    bsr_len=0;
    //LOG_D(MAC,"[UE %d] Empty buffers, send a long BSR to reset the bsr at eNB \n ",Mod_id);
    //    bsr_ce_len = sizeof(BSR_LONG);
    //bsr_len = bsr_ce_len + bsr_header_len;
  }
1263

1264 1265 1266 1267 1268 1269 1270 1271 1272
  phr_ce_len = (UE_mac_inst[module_idP].PHR_reporting_active == 1) ? 1 /* sizeof(POWER_HEADROOM_CMD)*/: 0;
  if (phr_ce_len > 0) {
    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;
  }

1273
  // check for UL bandwidth requests and add SR control element
1274 1275

  // check for UL bandwidth requests and add SR control element
1276 1277

  // Check for DCCH first
1278 1279 1280

  if (UE_mac_inst[module_idP].scheduling_info.LCID_status[DCCH] == LCID_NOT_EMPTY) {

1281 1282 1283 1284 1285 1286
    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
1287 1288 1289
                                    DCCH,
                                    (buflen-dcch_header_len-bsr_len-phr_len));
    LOG_D(MAC, "[UE %d] Frame %d : UL-DCCH -> ULSCH, RRC message has %d bytes to "
Cedric Roux's avatar
Cedric Roux committed
1290
          "send (Transport Block size %d, mac header len %d)\n",
1291
          module_idP,frameP, rlc_status.bytes_in_buffer,buflen,dcch_header_len);
1292

1293 1294 1295 1296 1297 1298
    sdu_lengths[0] += mac_rlc_data_req(module_idP, 
				       UE_mac_inst[module_idP].crnti,
				       eNB_index,
				       frameP,
				       ENB_FLAG_NO, 
				       MBMS_FLAG_NO,
1299 1300
                                       DCCH,
                                       (char *)&ulsch_buff[sdu_lengths[0]]);
1301

1302 1303 1304 1305
    sdu_length_total += sdu_lengths[0];
    sdu_lcids[0] = DCCH;
    LOG_D(MAC,"[UE %d] TX Got %d bytes for DCCH\n",module_idP,sdu_lengths[0]);
    num_sdus = 1;
1306
    //update_bsr(module_idP, frameP, eNB_index, DCCH, UE_mac_inst[module_idP].scheduling_info.LCGID[DCCH]);
1307
    //header_len +=2;
1308
    UE_mac_inst[module_idP].scheduling_info.LCID_status[DCCH] = LCID_EMPTY;
1309 1310 1311
  } else {
    dcch_header_len=0;
    num_sdus = 0;
1312 1313
  }

1314 1315 1316
  // if the RLC AM is used, then RLC will only provide 2 bytes for ACK
  // in this case, we sould add bsr

1317
  // DCCH1
1318
  if (UE_mac_inst[module_idP].scheduling_info.LCID_status[DCCH1] == LCID_NOT_EMPTY) {
1319

1320 1321 1322 1323 1324 1325
    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
1326 1327
                                    DCCH1,
                                    (buflen-bsr_len-phr_len-dcch_header_len-dcch1_header_len-sdu_length_total));
1328

1329
    LOG_D(MAC,"[UE %d] Frame %d : UL-DCCH1 -> ULSCH, RRC message has %d bytes to"
Cedric Roux's avatar
Cedric Roux committed
1330
          " send (Transport Block size %d, mac header len %d)\n",
1331
          module_idP,frameP, rlc_status.bytes_in_buffer,buflen,dcch1_header_len);
1332

1333 1334 1335 1336 1337 1338 1339 1340
    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,
					     DCCH1,
					     (char *)&ulsch_buff[sdu_lengths[num_sdus]]);
1341 1342 1343 1344 1345 1346
    sdu_length_total += sdu_lengths[num_sdus];
    sdu_lcids[num_sdus] = DCCH1;
    LOG_D(MAC,"[UE %d] TX Got %d bytes for DCCH1\n",module_idP,sdu_lengths[num_sdus]);
    num_sdus++;
    //update_bsr(module_idP, frameP, DCCH1);
    //dcch_header_len +=2; // include dcch1
1347
    UE_mac_inst[module_idP].scheduling_info.LCID_status[DCCH1] = LCID_EMPTY;
1348 1349
  } else {
    dcch1_header_len =0;
1350 1351
  }

1352 1353 1354 1355 1356 1357
  dtch_header_len=0;
  dtch_header_len_last=0;
  for (lcid=NB_RB_MAX-1; lcid>=DTCH ; lcid--){
    dtch_header_len+=3; 
    dtch_header_len_last=3;
    
1358
    all_pdu_len = bsr_len+phr_len+dcch_header_len+dcch1_header_len+dtch_header_len+sdu_length_total;
1359
    if ((UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] == LCID_NOT_EMPTY) &&
1360
      (all_pdu_len <= buflen)) {
1361 1362 1363 1364 1365 1366 1367

    // optimize the dtch header lenght
    //if ((UE_mac_inst[module_idP].scheduling_info.BSR_bytes[DTCH] > 128) &&
    /*   if (((UE_mac_inst[module_idP].scheduling_info.BSR_bytes[DTCH] >= 128) &&
    ((UE_mac_inst[module_idP].scheduling_info.BSR_bytes[DTCH]+bsr_len+phr_len+dcch_header_len+dcch1_header_len+dtch_header_len) > buflen)&&
    buflen >=128 ))
    dtch_header_len = 3;//sizeof(SCH_SUBHEADER_LONG);
1368
    else
1369 1370
    dtch_header_len = 2;//sizeof(SCH_SUBHEADER_SHORT);
     */
1371 1372 1373 1374 1375 1376 1377
      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,
1378
                      buflen-all_pdu_len);
1379 1380 1381

      LOG_D(MAC,"[UE %d] Frame %d : UL-DTCH -> ULSCH%d, %d bytes to send (Transport Block size %d, mac header len %d, BSR byte[%d] %d)\n",
	    module_idP,frameP, lcid, rlc_status.bytes_in_buffer,buflen,dtch_header_len,
1382
	    lcid, UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]]);
1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
      
       if (rlc_status.bytes_in_buffer > 0) {
	 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, // eNB_index
						  lcid,
						  (char *)&ulsch_buff[sdu_length_total]);
	 
	 //adjust dtch header
	 LOG_D(MAC,"[UE %d] TX Got %d bytes for DTCH\n",module_idP,sdu_lengths[num_sdus]);
	 sdu_lcids[num_sdus] = lcid;
	 sdu_length_total += sdu_lengths[num_sdus];
	 if (sdu_lengths[num_sdus] < 128) {
	   dtch_header_len --;
	   dtch_header_len_last --;
	 }
	 num_sdus++;
1403
	 //UE_mac_inst[module_idP].ul_active = update_bsr(module_idP, frameP, eNB_index,lcid, UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]);
1404 1405 1406
       } else {
	 dtch_header_len -= 3;
       }
1407
           UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] = LCID_EMPTY;
1408 1409 1410
    } else { // no rlc pdu : generate the dummy header
      dtch_header_len -= 3;
    }
1411 1412
  }

1413
  lcgid= get_bsr_lcgid(module_idP);
1414

1415
  if (lcgid < 0 ) {
1416
    bsr_s = NULL;
1417 1418 1419 1420 1421 1422 1423 1424
    bsr_l = NULL ;
  } else if ((lcgid ==MAX_NUM_LCGID) && (bsr_ce_len == sizeof(BSR_LONG))) {
    bsr_s = 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];

calvin wang's avatar
calvin wang committed
1425 1426 1427 1428 1429 1430
    LOG_D(MAC, "[UE %d] Frame %d report long BSR (level LCGID0 %d,level LCGID1 %d,level LCGID2 %d,level LCGID3 %d)\n", module_idP,frameP,
          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]);
    
1431 1432 1433 1434 1435 1436 1437 1438 1439
    UE_mac_inst[module_idP].scheduling_info.BSR_bytes[LCGID0] = 0;
    UE_mac_inst[module_idP].scheduling_info.BSR_bytes[LCGID1] = 0;
    UE_mac_inst[module_idP].scheduling_info.BSR_bytes[LCGID2] = 0;
    UE_mac_inst[module_idP].scheduling_info.BSR_bytes[LCGID3] = 0;
    UE_mac_inst[module_idP].scheduling_info.BSR[LCGID0] = 0;
    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;
  } else if (bsr_ce_len == sizeof(BSR_SHORT)) {
1440
    bsr_l = NULL;
1441 1442 1443 1444 1445 1446 1447
    bsr_s->LCGID = lcgid;
    bsr_s->Buffer_size = UE_mac_inst[module_idP].scheduling_info.BSR[lcgid];
    
    UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcgid] = 0;
    UE_mac_inst[module_idP].scheduling_info.BSR[lcgid] = 0;
    
    LOG_D(MAC,"[UE %d] Frame %d report SHORT BSR with level %d for LCGID %d\n",
1448
          module_idP, frameP, UE_mac_inst[module_idP].scheduling_info.BSR[lcgid],lcgid);
1449
  } else {
1450 1451
    bsr_s = NULL;
    bsr_l = NULL;
1452 1453
  }

1454
  // build PHR and update the timers
1455
  if (phr_ce_len == sizeof(POWER_HEADROOM_CMD)) {
Raymond Knopp's avatar
 
Raymond Knopp committed
1456 1457 1458 1459 1460
    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);
1461
  } else {
1462
    phr_p=NULL;
1463
  }
1464

1465
  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);
1466

1467 1468 1469
  if (dtch_header_len == 0 )
    dtch_header_len_last =0;

1470
  // adjust the header length
1471 1472
  dcch_header_len_tmp = dcch_header_len;
  dtch_header_len_tmp = dtch_header_len;
1473

1474
  if (dtch_header_len==0) {
1475
    dcch_header_len = (dcch_header_len>0)? 1: dcch_header_len;
1476
  } else {
1477 1478
    dtch_header_len_last-=1; 
    dtch_header_len= (dtch_header_len >0)? dtch_header_len - dtch_header_len_last : dtch_header_len;   
1479
  }
1480 1481 1482 1483 1484
  // 1-bit padding or 2-bit padding  special padding subheader
  padding_len = buflen-bsr_len-phr_len-dcch_header_len-dcch1_header_len-dtch_header_len-sdu_length_total;
  if (padding_len <= 2) {
    short_padding = padding_len;
    // only add padding header
1485 1486
    post_padding = 0;
  } else {
1487
    if (padding_len == buflen) {// nona mac pdu
1488 1489 1490 1491 1492
      *access_mode=CANCELED_ACCESS;
    }

    short_padding = 0;

1493
    if (dtch_header_len==0) {
1494
      dcch_header_len = dcch_header_len_tmp;
1495
    } else {
1496
      dtch_header_len= dtch_header_len_tmp;
1497
    }
1498

1499
    post_padding = buflen-bsr_len-phr_len-dcch_header_len-dcch1_header_len-dtch_header_len-sdu_length_total -1 ;
1500
  }
1501

1502 1503
  // Generate header
  // if (num_sdus>0) {
1504

1505
  payload_offset = generate_ulsch_header(ulsch_buffer,  // mac header
1506 1507 1508 1509 1510 1511
                                         num_sdus,      // num sdus
                                         short_padding,            // short pading
                                         sdu_lengths,  // sdu length
                                         sdu_lcids,    // sdu lcid
                                         phr_p,  // power headroom
                                         NULL,  // crnti
1512
                                         NULL,  // truncated bsr
1513 1514 1515 1516
                                         bsr_s, // short bsr
                                         bsr_l,
                                         post_padding); // long_bsr

1517
  LOG_D(MAC,
1518 1519 1520
        "[UE %d] Generate header :bufflen %d  sdu_length_total %d, num_sdus %d, sdu_lengths[0] %d, sdu_lcids[0] %d => payload offset %d,  dcch_header_len %d, dtch_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, dcch_header_len,  dtch_header_len,
        short_padding,post_padding, bsr_len, phr_len,buflen-sdu_length_total-payload_offset);
1521 1522
  // cycle through SDUs and place in ulsch_buffer
  memcpy(&ulsch_buffer[payload_offset],ulsch_buff,sdu_length_total);
1523

1524
  // fill remainder of DLSCH with random data
1525
  for (j=0; j<(buflen-sdu_length_total-payload_offset); j++) {
1526
    ulsch_buffer[payload_offset+sdu_length_total+j] = (char)(taus()&0xff);
1527
  }
1528
  LOG_D(MAC,"[UE %d][SR] Gave SDU to PHY, clearing any scheduling request\n",
1529
        module_idP,payload_offset, sdu_length_total);
1530 1531
  UE_mac_inst[module_idP].scheduling_info.SR_pending=0;
  UE_mac_inst[module_idP].scheduling_info.SR_COUNTER=0;
1532 1533 1534
  UE_mac_inst[module_idP].BSR_reporting_active=0;
  UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF  =  get_sf_periodicBSRTimer(UE_mac_inst[module_idP].scheduling_info.periodicBSR_Timer);
  UE_mac_inst[module_idP].scheduling_info.retxBSR_SF     =  get_sf_retxBSRTimer(UE_mac_inst[module_idP].scheduling_info.retxBSR_Timer);
1535
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GET_SDU, VCD_FUNCTION_OUT);
1536
  stop_meas(&UE_mac_inst[module_idP].tx_ulsch_sdu);
navid's avatar
navid committed
1537 1538 1539 1540 1541 1542
  
  if (opt_enabled) {
    trace_pdu(0, ulsch_buffer, buflen, module_idP, 3, UE_mac_inst[module_idP].crnti, UE_mac_inst[module_idP].subframe, 0, 0);
    LOG_D(OPT,"[UE %d][ULSCH] Frame %d trace pdu for rnti %x  with size %d\n",
          module_idP, UE_mac_inst[module_idP].subframe, UE_mac_inst[module_idP].crnti, buflen);
  }
1543 1544
}

1545
//------------------------------------------------------------------------------
1546 1547 1548 1549 1550 1551 1552
// 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

1553 1554 1555 1556 1557 1558 1559 1560 1561
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)
//------------------------------------------------------------------------------
1562
{
1563 1564 1565

  int lcid; // lcid index
  int TTI= 1;
winckel's avatar
winckel committed
1566 1567
  int bucketsizeduration = -1;
  int bucketsizeduration_max = -1;
1568
  // mac_rlc_status_resp_t rlc_status[MAX_NUM_LCGID]; // 4
1569
  // int8_t lcg_id;
1570
  struct RACH_ConfigCommon *rach_ConfigCommon = (struct RACH_ConfigCommon *)NULL;
1571
  protocol_ctxt_t   ctxt;
1572
#if defined(ENABLE_ITTI)
1573 1574 1575 1576
  MessageDef   *msg_p;
  const char   *msg_name;
  instance_t    instance;
  int           result;
1577
#endif
1578
  start_meas(&UE_mac_inst[module_idP].ue_scheduler);
1579
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_IN);
1580

1581
  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, module_idP, ENB_FLAG_NO, UE_mac_inst[module_idP].crnti, frameP, subframeP,eNB_indexP);
1582 1583
#if defined(ENABLE_ITTI)

1584 1585 1586
  do {
    // Checks if a message has been sent to MAC sub-task
    itti_poll_msg (TASK_MAC_UE, &msg_p);
1587

1588 1589 1590
    if (msg_p != NULL) {
      msg_name = ITTI_MSG_NAME (msg_p);
      instance = ITTI_MSG_INSTANCE (msg_p);
1591

1592 1593 1594 1595 1596
      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);
1597

1598 1599
        // TODO process CCCH data req.
        break;
1600 1601


1602 1603 1604
      default:
        LOG_E(MAC, "Received unexpected message %s\n", msg_name);
        break;
1605
      }
1606 1607 1608 1609

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

1612 1613
#endif

1614 1615
  //Mac_rlc_xface->frameP=frameP;
  //Rrc_xface->Frame_index=Mac_rlc_xface->frameP;
1616
  //if (subframe%5 == 0)
1617
  //LG#ifdef EXMIMO
1618
  pdcp_run(&ctxt);
1619
  //#endif
1620 1621
  UE_mac_inst[module_idP].frame = frameP;
  UE_mac_inst[module_idP].subframe = subframeP;
1622 1623

#ifdef CELLULAR
1624
  rrc_rx_tx(module_idP, frameP, 0, eNB_indexP);
1625
#else
1626

1627
  switch (rrc_rx_tx(&ctxt,
1628 1629
                    eNB_indexP,
                    CC_id)) {
1630 1631
  case RRC_OK:
    break;
1632

1633 1634
  case RRC_ConnSetup_failed:
    LOG_E(MAC,"RRCConnectionSetup failed, returning to IDLE state\n");
1635
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
1636
    stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
1637 1638
    return(CONNECTION_LOST);
    break;
1639

1640 1641
  case RRC_PHY_RESYNCH:
    LOG_E(MAC,"RRC Loss of synch, returning PHY_RESYNCH\n");
1642
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
1643
    stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
1644
    return(PHY_RESYNCH);
1645

1646
  case RRC_Handover_failed:
1647
    LOG_N(MAC,"Handover failure for UE %d eNB_index %d\n",module_idP,eNB_indexP);
1648
    //Invalid...need to add another MAC UE state for re-connection procedure
1649
    mac_xface->phy_config_afterHO_ue(module_idP,0,eNB_indexP,(MobilityControlInfo_t *)NULL,1);
1650 1651
    //return(3);
    break;
1652

1653 1654
  case RRC_HO_STARTED:
    LOG_I(MAC,"RRC handover, Instruct PHY to start the contention-free PRACH and synchronization\n");
1655
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
1656
    stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
1657
    return(PHY_HO_PRACH);
1658

1659 1660 1661
  default:
    break;
  }
1662

1663
#endif
1664 1665

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

1668
    if (UE_mac_inst[module_idP].radioResourceConfigCommon) {
1669
      rach_ConfigCommon = &UE_mac_inst[module_idP].radioResourceConfigCommon->rach_ConfigCommon;
1670
    } else {
1671
      LOG_E(MAC,"FATAL: radioResourceConfigCommon is NULL!!!\n");
1672
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
1673 1674 1675 1676
      stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
      mac_xface->macphy_exit("");
      //return(RRC_OK);
    }
1677

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

1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
    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);
    }
1691 1692 1693 1694 1695
  }


  // 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
1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711
  // Call BSR procedure as described in Section 5.4.5 in 36.321
  if (UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF == get_sf_periodicBSRTimer(MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_infinity)) {
    UE_mac_inst[module_idP].BSR_reporting_active = 1;
  } else if (UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF <= 0 ){
    // trigger BSR and reset the timer later when the BSR report is sent
    UE_mac_inst[module_idP].BSR_reporting_active = 1;
  } else if (UE_mac_inst[module_idP].BSR_reporting_active == 0 ) {
    UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF--;
  }

  if (UE_mac_inst[module_idP].scheduling_info.retxBSR_SF <= 0){
      // trigger BSR and reset the timer later when the BSR report is sent
      UE_mac_inst[module_idP].BSR_reporting_active = 1;
  } else if (UE_mac_inst[module_idP].BSR_reporting_active == 0 ) {
      UE_mac_inst[module_idP].scheduling_info.retxBSR_SF--;
  }
1712

1713
  // Get RLC status info and update Bj for all lcids that are active
1714
  for (lcid=DCCH; lcid < MAX_NUM_LCID; lcid++ ) {
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725
    if ((lcid == 0) ||(UE_mac_inst[module_idP].logicalChannelConfig[lcid])) {
      // 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("");
        }

1726
        if ( UE_mac_inst[module_idP].scheduling_info.Bj[lcid] > bucketsizeduration_max ) {
1727
          UE_mac_inst[module_idP].scheduling_info.Bj[lcid] = bucketsizeduration_max;
1728
        } else {
1729
          UE_mac_inst[module_idP].scheduling_info.Bj[lcid] = bucketsizeduration;
1730
        }
1731 1732
      }

1733
      if (update_bsr(module_idP,frameP, eNB_indexP, lcid, UE_mac_inst[module_idP].scheduling_info.LCGID[lcid])) {
1734
        UE_mac_inst[module_idP].scheduling_info.SR_pending= 1;
1735 1736
        // Regular BSR trigger
        UE_mac_inst[module_idP].BSR_reporting_active = 1;
1737 1738 1739 1740
        LOG_D(MAC,"[UE %d][SR] Frame %d subframe %d SR for PUSCH is pending for LCGID %d with BSR level %d (%d bytes in RLC)\n",
              module_idP, frameP,subframeP,UE_mac_inst[module_idP].scheduling_info.LCGID[lcid],
              UE_mac_inst[module_idP].scheduling_info.BSR[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]],
              UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[lcid]]);
1741
      }
1742
    }
1743
  }
1744

1745
  // UE has no valid phy config dedicated ||  no valid/released  SR
1746
  if ((UE_mac_inst[module_idP].physicalConfigDedicated == NULL)) {
1747 1748 1749 1750
    // 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);
1751
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
1752 1753
    stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
    return(CONNECTION_OK);
1754 1755
  }

1756
  if ((UE_mac_inst[module_idP].physicalConfigDedicated->schedulingRequestConfig == NULL) ||
1757
      (UE_mac_inst[module_idP].physicalConfigDedicated->schedulingRequestConfig->present == SchedulingRequestConfig_PR_release)) {
1758

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

1761 1762 1763 1764
    // 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);
1765 1766 1767
  }

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

1771 1772 1773 1774 1775 1776
    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) &&
1777 1778 1779
          ((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
1780
      {
1781
        UE_mac_inst[module_idP].PHR_reporting_active = 1;
1782
      } else if (UE_mac_inst[module_idP].PHR_reporting_active ==0 ) {
1783
        UE_mac_inst[module_idP].scheduling_info.prohibitPHR_SF--;
1784
      }
1785

1786
      if (UE_mac_inst[module_idP].scheduling_info.periodicPHR_SF <= 0 )
1787
        // trigger PHR and reset the timer later when the PHR report is sent
1788
      {
1789
        UE_mac_inst[module_idP].PHR_reporting_active = 1;
1790
      } else if (UE_mac_inst[module_idP].PHR_reporting_active == 0 ) {
1791
        UE_mac_inst[module_idP].scheduling_info.periodicPHR_SF--;
1792
      }
1793
    }
1794
  } else {    // release / nothing
1795
    UE_mac_inst[module_idP].PHR_reporting_active = 0; // release PHR
1796
  }
1797

1798
  //If the UE has UL resources allocated for new transmission for this TTI here:
1799
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SCHEDULER, VCD_FUNCTION_OUT);
1800
  stop_meas(&UE_mac_inst[module_idP].ue_scheduler);
1801 1802 1803 1804 1805
  return(CONNECTION_OK);
}

// to be improved
#ifdef CBA
1806
extern int cba_backoff;
1807 1808
double uniform_rngen(int min, int max)
{
1809 1810 1811 1812
  double random = (double)taus()/((double)0xffffffff);
  return (max - min) * random + min;
}

1813 1814
int cba_access(module_id_t module_idP,frame_t frameP,sub_frame_t subframe, uint8_t eNB_index,uint16_t buflen)
{
1815

1816 1817 1818 1819
  mac_rlc_status_resp_t rlc_status;
  int header_offset=4;
  int rv =0;

1820
  /*
1821 1822 1823 1824 1825
  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
1826
      //  LOG_D(MAC,"[UE %d] Frame %d Subframe %d: the current CBA backoff is %d \n", module_idP, frameP, subframe,
1827 1828
      //  UE_mac_inst[module_idP].cba_last_access[0] );

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

1833
      rv=1;
1834 1835 1836 1837 1838 1839 1840 1841
  } 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",
1842
          module_idP, frameP, subframe,
1843 1844
          UE_mac_inst[module_idP].cba_last_access[0], UE_mac_inst[module_idP].ul_active);

1845 1846 1847 1848
  } 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) ){
1849
    UE_mac_inst[module_idP].cba_last_access[0]-=1;
1850
    }*/
1851

1852
  if ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID0]>0)&&(UE_mac_inst[module_idP].scheduling_info.BSR[LCGID0]<64) ) {
1853
    return 0;
1854
  }
1855

1856 1857
  if ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1] <= 0 ) &&
      (UE_mac_inst[module_idP].scheduling_info.BSR[LCGID2] <= 0 ) &&
1858
      (UE_mac_inst[module_idP].scheduling_info.BSR[LCGID3] <= 0 ) ) {
1859
    return 0;
1860
  }
1861

1862
  if (cba_backoff == 0 ) { // apply probablisitc method
1863
    UE_mac_inst[module_idP].cba_last_access[0]= uniform_rngen(0,1);
1864 1865

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

1869 1870
      rv=1;
    }
1871 1872
  } else {

1873 1874
    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));
1875

1876
      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,
1877 1878 1879 1880
            UE_mac_inst[module_idP].cba_last_access[0], cba_backoff,UE_mac_inst[module_idP].ul_active);

      rv = 1;
      /*
1881
      rlc_status = mac_rlc_status_ind(module_idP, UE_mac_inst[module_idP].crnti,frameP,ENB_FLAG_NO,MBMS_FLAG_NO, // eNB_index
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
      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);
1896 1897 1898 1899
      */
    } 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",
1900 1901 1902
            module_idP, frameP, subframe,
            UE_mac_inst[module_idP].cba_last_access[0], UE_mac_inst[module_idP].ul_active);
    }
1903
  }
1904

1905 1906 1907
  return rv;
  /*
    if (( ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1]>0)&&(UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1]<64))   ||
1908 1909 1910 1911 1912
    ((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) ) {

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

1915
      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,
1916 1917 1918 1919
      UE_mac_inst[module_idP].cba_last_access[0], cba_backoff,UE_mac_inst[module_idP].ul_active);

      rv = 1;

1920
    rlc_status = mac_rlc_status_ind(module_idP, UE_mac_inst[module_idP].crnti,frameP,ENB_FLAG_NO,MBMS_FLAG_NO, // eNB_index
1921 1922 1923
            DTCH,
            0);

1924
    if ((
1925 1926 1927 1928 1929
   // (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 )
   )){
1930
      rv = 1;
1931

1932 1933
      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,
1934 1935
      UE_mac_inst[module_idP].cba_last_access[0], UE_mac_inst[module_idP].ul_active);
    } else
1936
      UE_mac_inst[module_idP].cba_last_access[0]= round(uniform_rngen(1,5));
1937

1938 1939

    } else if (( ((UE_mac_inst[module_idP].scheduling_info.BSR[LCGID1]> 0 ))   ||
1940 1941 1942 1943
     ((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) )
1944
      {
1945 1946 1947 1948 1949

  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);
1950 1951
      }
  }
1952 1953
  */

1954 1955 1956
}
#endif

1957
int get_bsr_lcgid (module_id_t module_idP)
1958
{
1959 1960
  int lcgid, lcgid_tmp=-1;
  int num_active_lcgid = 0;
1961

1962 1963
  for (lcgid = 0 ; lcgid < MAX_NUM_LCGID; lcgid++) {
    if (UE_mac_inst[module_idP].scheduling_info.BSR[lcgid] > 0 ) {
1964
      lcgid_tmp = lcgid;
1965 1966
      num_active_lcgid+=1;
    }
1967
  }
1968

1969
  if (num_active_lcgid == 0) {
1970 1971 1972
    return -1;
  } else if (num_active_lcgid == 1) {
    return lcgid_tmp;
1973
  } else {
1974
    return MAX_NUM_LCGID;
1975
  }
1976 1977
}

1978
uint8_t get_bsr_len (module_id_t module_idP, uint8_t eNB_index,frame_t frameP,uint16_t buflen)
1979
{
1980 1981
  int lcid;
  uint8_t bsr_len=0,  num_lcid=0;
1982
  int pdu = 0;
1983 1984 1985 1986 1987 1988 1989 1990 1991
  mac_rlc_status_resp_t rlc_status;

  for (lcid=DCCH; lcid<NB_RB_MAX ; 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);
    if (rlc_status.bytes_in_buffer > 0 ) {
      pdu += rlc_status.bytes_in_buffer + sizeof(SCH_SUBHEADER_SHORT) + bsr_len;
      if (rlc_status.bytes_in_buffer > 128 ) {
        pdu += 1;  //sizeof(SCH_SUBHEADER_LONG)
      }
1992
    }
1993 1994 1995
    if ( (pdu > buflen) && (rlc_status.bytes_in_buffer > 0 ) ) {
      num_lcid +=1;
      bsr_len = (num_lcid >= 2 ) ? sizeof(BSR_LONG) :  sizeof(BSR_SHORT) ;
1996
    }
1997
    LOG_D(MAC,"LC buffer Bytes %d for lcid %d bsr len %d num lcid %d\n", rlc_status.bytes_in_buffer, lcid, bsr_len, num_lcid);
1998
  }
1999

2000
  if ( bsr_len > 0 )
2001
    LOG_D(MAC,"[UE %d] Prepare a %s (Transport Block Size %d, MAC pdu Size %d) \n",
2002 2003
          module_idP, map_int_to_str(BSR_names, bsr_len), buflen, pdu);

2004 2005 2006
  return bsr_len;
}

2007
boolean_t  update_bsr(module_id_t module_idP, frame_t frameP, eNB_index_t eNB_index, uint8_t lcid, uint8_t lcg_id)
2008
{
2009 2010

  mac_rlc_status_resp_t rlc_status;
2011
  boolean_t sr_pending = FALSE;
Raymond Knopp's avatar
 
Raymond Knopp committed
2012 2013


2014
  if ((lcg_id < 0) || (lcg_id >= MAX_NUM_LCGID) ) {
2015
    return sr_pending;
2016
  }
2017

2018
  // fixme: need a better way to reset
2019 2020 2021
  if ((lcid == DCCH) || (lcid == DTCH)) {
    UE_mac_inst[module_idP].scheduling_info.BSR[lcg_id]=0;
    UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcg_id]=0;
2022
  }
2023

2024
  //  for (lcid =0 ; lcid < MAX_NUM_LCID; lcid++) {
2025
  if (UE_mac_inst[module_idP].scheduling_info.LCGID[lcid] == lcg_id) {
2026
    rlc_status = mac_rlc_status_ind(module_idP, UE_mac_inst[module_idP].crnti,eNB_index,frameP,ENB_FLAG_NO,MBMS_FLAG_NO,
2027 2028 2029 2030
                                    lcid,
                                    0);

    if (rlc_status.bytes_in_buffer > 0 ) {
2031
      //BSR trigger SR  
2032
      sr_pending = TRUE;
2033
      UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] = LCID_NOT_EMPTY;
2034 2035 2036
      // sum lcid buffer which has same lcgid
      UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcg_id] += rlc_status.bytes_in_buffer;
      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]);
2037 2038 2039
      // UE_mac_inst[module_idP].scheduling_info.BSR_short_lcid = lcid; // only applicable to short bsr
      LOG_D(MAC,"[UE %d] BSR level %d (LCGID %d, rlc buffer %d byte)\n",
            module_idP, UE_mac_inst[module_idP].scheduling_info.BSR[lcg_id],lcg_id,  UE_mac_inst[module_idP].scheduling_info.BSR_bytes[lcg_id]);
2040
    } else {
2041
      UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid]=LCID_EMPTY;
2042
    }
2043
  }
2044

2045
  //}
2046
  return sr_pending;
2047 2048
}

2049
uint8_t locate_BsrIndexByBufferSize (const uint32_t *table, int size, int value)
2050
{
2051

2052
  uint8_t ju, jm, jl;
2053 2054
  int ascend;

2055 2056 2057
  DevAssert( size > 0 );
  DevAssert( size <= 256 );

2058 2059 2060
  if (value == 0) {
    return 0;  //elseif (value > 150000) return 63;
  }
2061

2062 2063
  jl = 0;        // lower bound
  ju = size - 1; // upper bound
2064 2065 2066
  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,
2067 2068
    jm = (ju+jl) >> 1; //compute a midpoint,

2069
    if ((value >= table[jm]) == ascend) {
2070
      jl=jm; // replace the lower limit
2071
    } else {
2072
      ju=jm; //replace the upper limit
2073
    }
2074 2075

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

2078 2079
  if (value == table[jl]) {
    return jl;
2080
  } else {
2081 2082
    return jl+1;  //equally  ju
  }
2083 2084 2085

}

2086 2087
int get_sf_periodicBSRTimer(uint8_t sf_offset)
{
2088 2089 2090 2091 2092

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

2094 2095 2096
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf10:
    return 10;
    break;
2097

2098 2099 2100
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf16:
    return 16;
    break;
2101

2102 2103 2104
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf20:
    return 20;
    break;
2105

2106 2107 2108
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf32:
    return 32;
    break;
2109

2110 2111 2112
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf40:
    return 40;
    break;
2113

2114 2115 2116
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf64:
    return 64;
    break;
2117

2118 2119 2120
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf80:
    return 80;
    break;
2121

2122 2123 2124
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf128:
    return 128;
    break;
2125

2126 2127 2128
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf160:
    return 160;
    break;
2129

2130 2131 2132
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf320:
    return 320;
    break;
2133

2134 2135 2136
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf640:
    return 640;
    break;
2137

2138 2139 2140
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf1280:
    return 1280;
    break;
2141

2142 2143 2144
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_sf2560:
    return 2560;
    break;
2145

2146 2147 2148 2149 2150 2151 2152
  case MAC_MainConfig__ul_SCH_Config__periodicBSR_Timer_infinity:
  default:
    return -1;
    break;
  }
}

2153 2154
int get_sf_retxBSRTimer(uint8_t sf_offset)
{
2155 2156 2157 2158 2159

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

2161 2162 2163
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf640:
    return 640;
    break;
2164

2165 2166 2167
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf1280:
    return 1280;
    break;
2168

2169 2170 2171
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf2560:
    return 2560;
    break;
2172

2173 2174 2175
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf5120:
    return 5120;
    break;
2176

2177 2178 2179
  case MAC_MainConfig__ul_SCH_Config__retxBSR_Timer_sf10240:
    return 10240;
    break;
2180

2181 2182 2183 2184 2185
  default:
    return -1;
    break;
  }
}
2186 2187
int get_ms_bucketsizeduration(uint8_t bucketsizeduration)
{
2188 2189 2190 2191 2192

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

2194 2195 2196
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms100:
    return 100;
    break;
2197

2198 2199 2200
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms150:
    return 150;
    break;
2201

2202 2203 2204
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms300:
    return 300;
    break;
2205

2206 2207 2208
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms500:
    return 500;
    break;
2209

2210 2211 2212
  case LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms1000:
    return 1000;
    break;
2213

2214 2215 2216 2217 2218 2219
  default:
    return 0;
    break;
  }
}

2220 2221
void update_phr(module_id_t module_idP,int CC_id)
{
Raymond Knopp's avatar
 
Raymond Knopp committed
2222 2223 2224 2225 2226 2227

  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;
  }
2228 2229 2230 2231 2232

  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);
2233
}
2234 2235
uint8_t get_phr_mapping (module_id_t module_idP, int CC_id, uint8_t eNB_index)
{
2236

Raymond Knopp's avatar
 
Raymond Knopp committed
2237 2238 2239
  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");
2240
    return 0; // not reached
Raymond Knopp's avatar
 
Raymond Knopp committed
2241
  }
2242

2243 2244
  //power headroom reporting range is from -23 ...+40 dB, as described in 36313
  //note: mac_xface->get_Po_NOMINAL_PUSCH(module_idP) is float
2245
  if (mac_xface->get_PHR(module_idP,CC_id,eNB_index) < -23) {
2246
    return 0;
2247
  } else if (mac_xface->get_PHR(module_idP,CC_id,eNB_index) >= 40) {
2248
    return 63;
2249
  } else { // -23 to 40
Raymond Knopp's avatar
 
Raymond Knopp committed
2250
    return  (uint8_t) mac_xface->get_PHR(module_idP,CC_id,eNB_index) + PHR_MAPPING_OFFSET;
2251

2252
  }
2253
}
2254 2255
int get_sf_perioidicPHR_Timer(uint8_t perioidicPHR_Timer)
{
2256 2257 2258 2259
  return (perioidicPHR_Timer+1)*10;
}


2260 2261
int get_sf_prohibitPHR_Timer(uint8_t prohibitPHR_Timer)
{
2262 2263 2264
  return (prohibitPHR_Timer)*10;
}

2265 2266 2267
int get_db_dl_PathlossChange(uint8_t dl_PathlossChange)
{
  switch (dl_PathlossChange) {
2268 2269 2270
  case MAC_MainConfig__phr_Config__setup__dl_PathlossChange_dB1:
    return 1;
    break;
2271

2272 2273 2274
  case MAC_MainConfig__phr_Config__setup__dl_PathlossChange_dB3:
    return 3;
    break;
2275

2276 2277 2278
  case MAC_MainConfig__phr_Config__setup__dl_PathlossChange_dB6:
    return 6;
    break;
2279

2280 2281 2282 2283 2284 2285
  case MAC_MainConfig__phr_Config__setup__dl_PathlossChange_infinity:
  default:
    return -1;
    break;
  }
}