phy_procedures_lte_eNb.c 156 KB
Newer Older
1
/*******************************************************************************
2
    OpenAirInterface
ghaddab's avatar
ghaddab committed
3
    Copyright(c) 1999 - 2014 Eurecom
4

ghaddab's avatar
ghaddab committed
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


ghaddab's avatar
ghaddab committed
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

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

  Contact Information
ghaddab's avatar
ghaddab committed
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

ghaddab's avatar
ghaddab committed
28
 *******************************************************************************/
29 30 31

/*! \file phy_procedures_lte_eNB.c
 * \brief Implementation of eNB procedures from 36.213 LTE specifications
32
 * \author R. Knopp, F. Kaltenberger, N. Nikaein
33 34 35
 * \date 2011
 * \version 0.1
 * \company Eurecom
36
 * \email: knopp@eurecom.fr,florian.kaltenberger@eurecom.fr,navid.nikaein@eurecom.fr
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
 * \note
 * \warning
 */

#include "PHY/defs.h"
#include "PHY/extern.h"
#include "MAC_INTERFACE/defs.h"
#include "MAC_INTERFACE/extern.h"
#include "SCHED/defs.h"
#include "SCHED/extern.h"

#ifdef EMOS
#include "SCHED/phy_procedures_emos.h"
#endif

52
//#define DEBUG_PHY_PROC (Already defined in cmake)
53 54 55 56 57 58 59
//#define DEBUG_ULSCH

#include "LAYER2/MAC/extern.h"
#include "LAYER2/MAC/defs.h"
#include "UTIL/LOG/log.h"
#include "UTIL/LOG/vcd_signal_dumper.h"

60
#include "assertions.h"
gauthier's avatar
gauthier committed
61
#include "msc.h"
62

63 64
#include "T.h"

65
#if defined(ENABLE_ITTI)
gauthier's avatar
gauthier committed
66
#   include "intertask_interface.h"
67
#   if ENABLE_RAL
gauthier's avatar
gauthier committed
68 69
#     include "timer.h"
#   endif
70 71
#endif

72 73 74 75 76 77 78
//#define DIAG_PHY

#define NS_PER_SLOT 500000

#define PUCCH 1

extern int exit_openair;
79
//extern void do_OFDM_mod(mod_sym_t **txdataF, int32_t **txdata, uint32_t frame, uint16_t next_slot, LTE_DL_FRAME_PARMS *frame_parms);
80 81 82 83 84 85 86


unsigned char dlsch_input_buffer[2700] __attribute__ ((aligned(16)));
int eNB_sync_buffer0[640*6] __attribute__ ((aligned(16)));
int eNB_sync_buffer1[640*6] __attribute__ ((aligned(16)));
int *eNB_sync_buffer[2] = {eNB_sync_buffer0, eNB_sync_buffer1};

87
extern uint16_t hundred_times_log10_NPRB[100];
88

89
unsigned int max_peak_val;
90 91 92 93 94 95 96 97 98 99 100
int max_sect_id, max_sync_pos;

//DCI_ALLOC_t dci_alloc[8];

#ifdef EMOS
fifo_dump_emos_eNB emos_dump_eNB;
#endif

#if defined(SMBV) && !defined(EXMIMO)
extern const char smbv_fname[];
extern unsigned short config_frames[4];
101
extern uint8_t smbv_frame_cnt;
102 103 104 105 106 107
#endif

#ifdef DIAG_PHY
extern int rx_sig_fifo;
#endif

108 109
uint8_t is_SR_subframe(PHY_VARS_eNB *phy_vars_eNB,uint8_t UE_id,uint8_t sched_subframe)
{
110

gauthier's avatar
gauthier committed
111 112
  const int subframe = phy_vars_eNB->proc[sched_subframe].subframe_rx;
  const int frame = phy_vars_eNB->proc[sched_subframe].frame_rx;
113

114
  LOG_D(PHY,"[eNB %d][SR %x] Frame %d subframe %d Checking for SR TXOp(sr_ConfigIndex %d)\n",
115 116 117
        phy_vars_eNB->Mod_id,phy_vars_eNB->ulsch_eNB[UE_id]->rnti,frame,subframe,
        phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex);

118
  if (phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 4) {        // 5 ms SR period
119 120
    if ((subframe%5) == phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex)
      return(1);
121
  } else if (phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 14) { // 10 ms SR period
122 123
    if (subframe==(phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex-5))
      return(1);
124
  } else if (phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 34) { // 20 ms SR period
125
    if ((10*(frame&1)+subframe) == (phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex-15))
126
      return(1);
127
  } else if (phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 74) { // 40 ms SR period
128
    if ((10*(frame&3)+subframe) == (phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex-35))
129
      return(1);
130
  } else if (phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex <= 154) { // 80 ms SR period
131
    if ((10*(frame&7)+subframe) == (phy_vars_eNB->scheduling_request_config[UE_id].sr_ConfigIndex-75))
132
      return(1);
133 134 135 136
  }

  return(0);
}
137

138 139 140 141 142 143
void put_harq_pid_in_freelist(LTE_eNB_DLSCH_t *DLSCH_ptr, int harq_pid)
{
  DLSCH_ptr->harq_pid_freelist[DLSCH_ptr->tail_freelist] = harq_pid;
  DLSCH_ptr->tail_freelist = (DLSCH_ptr->tail_freelist + 1) % 10;
}

Cedric Roux's avatar
Cedric Roux committed
144
void remove_harq_pid_from_freelist(LTE_eNB_DLSCH_t *DLSCH_ptr, int harq_pid)
145 146 147 148 149
{
  if (DLSCH_ptr->head_freelist == DLSCH_ptr->tail_freelist) {
    LOG_E(PHY, "%s:%d: you cannot read this!\n", __FILE__, __LINE__);
    abort();
  }
Cedric Roux's avatar
Cedric Roux committed
150 151 152 153 154 155 156 157 158
  /* basic check, in case several threads deal with the free list at the same time
   * in normal situations it should not happen, that's also why we don't use any
   * locking mechanism to protect the free list
   * to be refined in case things don't work properly
   */
  if (harq_pid != DLSCH_ptr->harq_pid_freelist[DLSCH_ptr->head_freelist]) {
    LOG_E(PHY, "%s:%d: critical error, get in touch with the authors\n", __FILE__, __LINE__);
    abort();
  }
159 160 161
  DLSCH_ptr->head_freelist = (DLSCH_ptr->head_freelist + 1) % 10;
}

162 163
int32_t add_ue(int16_t rnti, PHY_VARS_eNB *phy_vars_eNB)
{
164
  uint8_t i;
165

166
#ifdef DEBUG_PHY_PROC
Cedric Roux's avatar
Cedric Roux committed
167 168 169 170
  LOG_I(PHY,"[eNB %d/%d] Adding UE with rnti %x\n",
        phy_vars_eNB->Mod_id,
        phy_vars_eNB->CC_id,
        (uint16_t)rnti);
171
#endif
172 173

  for (i=0; i<NUMBER_OF_UE_MAX; i++) {
174
    if ((phy_vars_eNB->dlsch_eNB[i]==NULL) || (phy_vars_eNB->ulsch_eNB[i]==NULL)) {
175
      MSC_LOG_EVENT(MSC_PHY_ENB, "0 Failed add ue %"PRIx16" (ENOMEM)", rnti);
176 177
      LOG_E(PHY,"Can't add UE, not enough memory allocated\n");
      return(-1);
178
    } else {
179
      if (phy_vars_eNB->eNB_UE_stats[i].crnti==0) {
180
        MSC_LOG_EVENT(MSC_PHY_ENB, "0 Add ue %"PRIx16" ", rnti);
Cedric Roux's avatar
Cedric Roux committed
181
        LOG_I(PHY,"UE_id %d associated with rnti %x\n",i, (uint16_t)rnti);
182 183 184
        phy_vars_eNB->dlsch_eNB[i][0]->rnti = rnti;
        phy_vars_eNB->ulsch_eNB[i]->rnti = rnti;
        phy_vars_eNB->eNB_UE_stats[i].crnti = rnti;
knopp's avatar
knopp committed
185 186 187 188 189 190 191 192 193

	phy_vars_eNB->eNB_UE_stats[i].Po_PUCCH1_below = 0;
	phy_vars_eNB->eNB_UE_stats[i].Po_PUCCH1_above = (int32_t)pow(10.0,.1*(phy_vars_eNB->lte_frame_parms.ul_power_control_config_common.p0_NominalPUCCH+phy_vars_eNB->rx_total_gain_eNB_dB));
	phy_vars_eNB->eNB_UE_stats[i].Po_PUCCH        = (int32_t)pow(10.0,.1*(phy_vars_eNB->lte_frame_parms.ul_power_control_config_common.p0_NominalPUCCH+phy_vars_eNB->rx_total_gain_eNB_dB));
	LOG_I(PHY,"Initializing Po_PUCCH: p0_NominalPUCCH %d, gain %d => %d\n",
	      phy_vars_eNB->lte_frame_parms.ul_power_control_config_common.p0_NominalPUCCH,
	      phy_vars_eNB->rx_total_gain_eNB_dB,
	      phy_vars_eNB->eNB_UE_stats[i].Po_PUCCH);
  
194
        return(i);
195
      }
196
    }
197 198 199 200
  }
  return(-1);
}

201 202
int32_t remove_ue(uint16_t rnti, PHY_VARS_eNB *phy_vars_eNB, uint8_t abstraction_flag)
{
203
  uint8_t i;
204
  int j;
205

206
  for (i=0; i<NUMBER_OF_UE_MAX; i++) {
207
    if ((phy_vars_eNB->dlsch_eNB[i]==NULL) || (phy_vars_eNB->ulsch_eNB[i]==NULL)) {
208
      MSC_LOG_EVENT(MSC_PHY_ENB, "0 Failed remove ue %"PRIx16" (ENOMEM)", rnti);
209 210
      LOG_E(PHY,"Can't remove UE, not enough memory allocated\n");
      return(-1);
211
    } else {
212
      if (phy_vars_eNB->eNB_UE_stats[i].crnti==rnti) {
213
        MSC_LOG_EVENT(MSC_PHY_ENB, "0 Removed ue %"PRIx16" ", rnti);
214 215 216
#ifdef DEBUG_PHY_PROC
	LOG_I(PHY,"eNB %d removing UE %d with rnti %x\n",phy_vars_eNB->Mod_id,i,rnti);
#endif
217 218 219 220 221 222
        //msg("[PHY] UE_id %d\n",i);
        clean_eNb_dlsch(phy_vars_eNB->dlsch_eNB[i][0], abstraction_flag);
        clean_eNb_ulsch(phy_vars_eNB->ulsch_eNB[i],abstraction_flag);
        //phy_vars_eNB->eNB_UE_stats[i].crnti = 0;
        memset(&phy_vars_eNB->eNB_UE_stats[i],0,sizeof(LTE_eNB_UE_stats));
        //  mac_exit_wrapper("Removing UE");
223 224 225 226 227 228 229

        /* clear the harq pid freelist */
        phy_vars_eNB->dlsch_eNB[i][0]->head_freelist = 0;
        phy_vars_eNB->dlsch_eNB[i][0]->tail_freelist = 0;
        for (j = 0; j < 8; j++)
          put_harq_pid_in_freelist(phy_vars_eNB->dlsch_eNB[i][0], j);

230
        return(i);
231
      }
232
    }
233
  }
234

235
  MSC_LOG_EVENT(MSC_PHY_ENB, "0 Failed remove ue %"PRIx16" (not found)", rnti);
236 237 238
  return(-1);
}

239 240
int8_t find_next_ue_index(PHY_VARS_eNB *phy_vars_eNB)
{
241
  uint8_t i;
242

243
  for (i=0; i<NUMBER_OF_UE_MAX; i++) {
244
    if (phy_vars_eNB->eNB_UE_stats[i].crnti==0) {
245 246 247
      /*if ((phy_vars_eNB->dlsch_eNB[i]) &&
      (phy_vars_eNB->dlsch_eNB[i][0]) &&
      (phy_vars_eNB->dlsch_eNB[i][0]->rnti==0))*/
248 249 250
      LOG_D(PHY,"Next free UE id is %d\n",i);
      return(i);
    }
251
  }
252

253 254 255
  return(-1);
}

gauthier's avatar
gauthier committed
256
int get_ue_active_harq_pid(const uint8_t Mod_id,const uint8_t CC_id,const uint16_t rnti, const int frame, const uint8_t subframe,uint8_t *harq_pid,uint8_t *round,const uint8_t ul_flag)
257 258 259 260
{
  LTE_eNB_DLSCH_t *DLSCH_ptr;
  LTE_eNB_ULSCH_t *ULSCH_ptr;
  uint8_t ulsch_subframe,ulsch_frame;
261
  uint8_t i;
262
  int8_t UE_id = find_ue(rnti,PHY_vars_eNB_g[Mod_id][CC_id]);
263
  int sf1=(10*frame)+subframe,sf2,sfdiff,sfdiff_max=7;
264 265

  if (UE_id==-1) {
266
    LOG_D(PHY,"Cannot find UE with rnti %x (Mod_id %d, CC_id %d)\n",rnti, Mod_id, CC_id);
267 268
    *round=0;
    return(-1);
269 270 271
  }

  if (ul_flag == 0)  {// this is a DL request
272
    DLSCH_ptr = PHY_vars_eNB_g[Mod_id][CC_id]->dlsch_eNB[(uint32_t)UE_id][0];
273

274 275 276 277 278
    // set to no available process first
    *harq_pid = -1;

    for (i=0; i<DLSCH_ptr->Mdlharq; i++) {
      if (DLSCH_ptr->harq_processes[i]!=NULL) {
279
	if (DLSCH_ptr->harq_processes[i]->status == ACTIVE) {
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
	  sf2 = (DLSCH_ptr->harq_processes[i]->frame*10) + DLSCH_ptr->harq_processes[i]->subframe;
	  if (sf2<=sf1)
	    sfdiff = sf1-sf2;
	  else // this happens when wrapping around 1024 frame barrier
	    sfdiff = 10240 + sf1-sf2;
	  LOG_D(PHY,"process %d is active, round %d (waiting %d)\n",i,DLSCH_ptr->harq_processes[i]->round,sfdiff);

	  if (sfdiff>sfdiff_max) { // this is an active process that is waiting longer than the others (and longer than 7 ms)
	    sfdiff_max = sfdiff; 
	    *harq_pid = i;
	    *round = DLSCH_ptr->harq_processes[i]->round;
	  }
	}
      } else { // a process is not defined
	LOG_E(PHY,"[eNB %d] DLSCH process %d for rnti %x (UE_id %d) not allocated\n",Mod_id,i,rnti,UE_id);
	return(-1);
296
      }
297
    }
298 299 300 301 302 303 304 305

    /* if no active harq pid, get the oldest in the freelist, if any */
    if (*harq_pid == 255 && DLSCH_ptr->head_freelist != DLSCH_ptr->tail_freelist) {
      *harq_pid = DLSCH_ptr->harq_pid_freelist[DLSCH_ptr->head_freelist];
      *round = 0;
      LOG_D(PHY,"process %d is first free process\n", *harq_pid);
    }

306 307
    LOG_D(PHY,"get_ue_active_harq_pid DL => Frame %d, Subframe %d : harq_pid %d\n",
	  frame,subframe,*harq_pid);
308
  } else { // This is a UL request
309

310 311 312
    ULSCH_ptr = PHY_vars_eNB_g[Mod_id][CC_id]->ulsch_eNB[(uint32_t)UE_id];
    ulsch_subframe = pdcch_alloc2ul_subframe(&PHY_vars_eNB_g[Mod_id][CC_id]->lte_frame_parms,subframe);
    ulsch_frame    = pdcch_alloc2ul_frame(&PHY_vars_eNB_g[Mod_id][CC_id]->lte_frame_parms,frame,subframe);
313
    // Note this is for TDD configuration 3,4,5 only
314
    *harq_pid = subframe2harq_pid(&PHY_vars_eNB_g[Mod_id][CC_id]->lte_frame_parms,
315 316
                                  ulsch_frame,
                                  ulsch_subframe);
317
    *round    = ULSCH_ptr->harq_processes[*harq_pid]->round;
318
    LOG_T(PHY,"[eNB %d][PUSCH %d] Frame %d subframe %d Checking HARQ, round %d\n",Mod_id,*harq_pid,frame,subframe,*round);
319
  }
320

321 322 323
  return(0);
}

knopp's avatar
knopp committed
324
int16_t get_target_pusch_rx_power(const module_id_t module_idP, const uint8_t CC_id)
325
{
326 327
  //return PHY_vars_eNB_g[module_idP][CC_id]->PHY_measurements_eNB[0].n0_power_tot_dBm;
  return PHY_vars_eNB_g[module_idP][CC_id]->lte_frame_parms.ul_power_control_config_common.p0_NominalPUSCH;
328 329
}

knopp's avatar
knopp committed
330 331 332 333 334 335
int16_t get_target_pucch_rx_power(const module_id_t module_idP, const uint8_t CC_id)
{
  //return PHY_vars_eNB_g[module_idP][CC_id]->PHY_measurements_eNB[0].n0_power_tot_dBm;
  return PHY_vars_eNB_g[module_idP][CC_id]->lte_frame_parms.ul_power_control_config_common.p0_NominalPUCCH;
}

336
#ifdef EMOS
337 338
void phy_procedures_emos_eNB_TX(unsigned char subframe, PHY_VARS_eNB *phy_vars_eNB)
{
339 340 341 342 343

}
#endif

/*
344
  void phy_procedures_eNB_S_TX(unsigned char next_slot,PHY_VARS_eNB *phy_vars_eNB,uint8_t abstraction_flag) {
345 346 347 348 349 350 351 352

  int sect_id = 0, aa;

  if (next_slot%2==0) {
  #ifdef DEBUG_PHY_PROC
  msg("[PHY][eNB %d] Frame %d, slot %d: Generating pilots for DL-S\n",
  phy_vars_eNB->Mod_id,phy_vars_eNB->frame,next_slot);
  #endif
353

354 355 356 357
  for (sect_id=0;sect_id<number_of_cards;sect_id++) {
  if (abstraction_flag == 0) {

  for (aa=0; aa<phy_vars_eNB->lte_frame_parms.nb_antennas_tx; aa++) {
358 359


360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
  #ifdef IFFT_FPGA
  memset(&phy_vars_eNB->lte_eNB_common_vars.txdataF[sect_id][aa][next_slot*(phy_vars_eNB->lte_frame_parms.N_RB_DL*12)*(phy_vars_eNB->lte_frame_parms.symbols_per_tti>>1)],
  0,(phy_vars_eNB->lte_frame_parms.N_RB_DL*12)*(phy_vars_eNB->lte_frame_parms.symbols_per_tti>>1)*sizeof(mod_sym_t));
  #else
  memset(&phy_vars_eNB->lte_eNB_common_vars.txdataF[sect_id][aa][next_slot*phy_vars_eNB->lte_frame_parms.ofdm_symbol_size*(phy_vars_eNB->lte_frame_parms.symbols_per_tti>>1)],
  0,phy_vars_eNB->lte_frame_parms.ofdm_symbol_size*(phy_vars_eNB->lte_frame_parms.symbols_per_tti>>1)*sizeof(mod_sym_t));
  #endif
  }

  generate_pilots_slot(phy_vars_eNB,
  phy_vars_eNB->lte_eNB_common_vars.txdataF[sect_id],
  AMP,
  next_slot);

  msg("[PHY][eNB] Frame %d, subframe %d Generating PSS\n",
  phy_vars_eNB->frame,next_slot>>1);
376

377 378 379 380 381
  generate_pss(phy_vars_eNB->lte_eNB_common_vars.txdataF[sect_id],
  4*AMP,
  &phy_vars_eNB->lte_frame_parms,
  2,
  next_slot);
382

383 384 385 386 387 388 389 390 391
  }
  else {
  #ifdef PHY_ABSTRACTION
  generate_pss_emul(phy_vars_eNB,sect_id);
  #endif
  }
  }
  }
  }
392
*/
393

394 395 396
void phy_procedures_eNB_S_RX(unsigned char sched_subframe,PHY_VARS_eNB *phy_vars_eNB,uint8_t abstraction_flag,relaying_type_t r_type)
{
  UNUSED(r_type);
397

398
  //  unsigned char sect_id=0;
399
  int subframe = phy_vars_eNB->proc[sched_subframe].subframe_rx;
400

401
#ifdef DEBUG_PHY_PROC
402
  LOG_D(PHY,"[eNB %d] Frame %d: Doing phy_procedures_eNB_S_RX(%d)\n", phy_vars_eNB->Mod_id,phy_vars_eNB->proc[sched_subframe].frame_rx, subframe);
403
#endif
404

405
  //  for (sect_id=0;sect_id<number_of_cards;sect_id++) {
406

407 408
  if (abstraction_flag == 0) {
    lte_eNB_I0_measurements(phy_vars_eNB,
409
			    subframe,
410 411
                            0,
                            phy_vars_eNB->first_run_I0_measurements);
412
  }
413

414
#ifdef PHY_ABSTRACTION
415 416
  else {
    lte_eNB_I0_measurements_emul(phy_vars_eNB,
417
                                 0);
418
  }
419

420 421
#endif

422

423 424
}

425 426


427
#ifdef EMOS
428 429 430
void phy_procedures_emos_eNB_RX(unsigned char subframe,PHY_VARS_eNB *phy_vars_eNB)
{

431 432 433 434
  uint8_t aa;
  uint16_t last_subframe_emos;
  uint16_t pilot_pos1 = 3 - phy_vars_eNB->lte_frame_parms.Ncp, pilot_pos2 = 10 - 2*phy_vars_eNB->lte_frame_parms.Ncp;
  uint32_t bytes;
435 436 437

  last_subframe_emos=0;

438

439

440

441
#ifdef EMOS_CHANNEL
442

443
  //if (last_slot%2==1) // this is for all UL subframes
444
  if (subframe==3)
445
    for (aa=0; aa<phy_vars_eNB->lte_frame_parms.nb_antennas_rx; aa++) {
446 447 448 449 450 451
      memcpy(&emos_dump_eNB.channel[aa][last_subframe_emos*2*phy_vars_eNB->lte_frame_parms.N_RB_UL*12],
             &phy_vars_eNB->lte_eNB_pusch_vars[0]->drs_ch_estimates[0][aa][phy_vars_eNB->lte_frame_parms.N_RB_UL*12*pilot_pos1],
             phy_vars_eNB->lte_frame_parms.N_RB_UL*12*sizeof(int));
      memcpy(&emos_dump_eNB.channel[aa][(last_subframe_emos*2+1)*phy_vars_eNB->lte_frame_parms.N_RB_UL*12],
             &phy_vars_eNB->lte_eNB_pusch_vars[0]->drs_ch_estimates[0][aa][phy_vars_eNB->lte_frame_parms.N_RB_UL*12*pilot_pos2],
             phy_vars_eNB->lte_frame_parms.N_RB_UL*12*sizeof(int));
452
    }
453

454 455
#endif

456
  if (subframe==4) {
457
    emos_dump_eNB.timestamp = rt_get_time_ns();
jiangx's avatar
jiangx committed
458
    emos_dump_eNB.frame_tx = phy_vars_eNB->proc[subframe].frame_rx;
459 460 461 462 463 464 465 466
    emos_dump_eNB.rx_total_gain_dB = phy_vars_eNB->rx_total_gain_eNB_dB;
    emos_dump_eNB.mimo_mode = phy_vars_eNB->transmission_mode[0];
    memcpy(&emos_dump_eNB.PHY_measurements_eNB,
           &phy_vars_eNB->PHY_measurements_eNB[0],
           sizeof(PHY_MEASUREMENTS_eNB));
    memcpy(&emos_dump_eNB.eNB_UE_stats[0],&phy_vars_eNB->eNB_UE_stats[0],NUMBER_OF_UE_MAX*sizeof(LTE_eNB_UE_stats));

    bytes = rtf_put(CHANSOUNDER_FIFO_MINOR, &emos_dump_eNB, sizeof(fifo_dump_emos_eNB));
467

468 469
    //bytes = rtf_put(CHANSOUNDER_FIFO_MINOR, "test", sizeof("test"));
    if (bytes!=sizeof(fifo_dump_emos_eNB)) {
470
      LOG_W(PHY,"[eNB %d] Frame %d, subframe %d, Problem writing EMOS data to FIFO (bytes=%d, size=%d)\n",
jiangx's avatar
jiangx committed
471
            phy_vars_eNB->Mod_id,phy_vars_eNB->proc[(subframe+1)%10].frame_rx, subframe,bytes,sizeof(fifo_dump_emos_eNB));
472
    } else {
473 474
      if (phy_vars_eNB->proc[(subframe+1)%10].frame_tx%100==0) {
        LOG_I(PHY,"[eNB %d] Frame %d (%d), subframe %d, Writing %d bytes EMOS data to FIFO\n",
jiangx's avatar
jiangx committed
475
              phy_vars_eNB->Mod_id,phy_vars_eNB->proc[(subframe+1)%10].frame_rx, ((fifo_dump_emos_eNB*)&emos_dump_eNB)->frame_tx, subframe, bytes);
476
      }
477
    }
478 479 480 481 482 483 484
  }
}
#endif


#define AMP_OVER_SQRT2 ((AMP*ONE_OVER_SQRT2_Q15)>>15)
#define AMP_OVER_2 (AMP>>1)
485 486
int QPSK[4]= {AMP_OVER_SQRT2|(AMP_OVER_SQRT2<<16),AMP_OVER_SQRT2|((65536-AMP_OVER_SQRT2)<<16),((65536-AMP_OVER_SQRT2)<<16)|AMP_OVER_SQRT2,((65536-AMP_OVER_SQRT2)<<16)|(65536-AMP_OVER_SQRT2)};
int QPSK2[4]= {AMP_OVER_2|(AMP_OVER_2<<16),AMP_OVER_2|((65536-AMP_OVER_2)<<16),((65536-AMP_OVER_2)<<16)|AMP_OVER_2,((65536-AMP_OVER_2)<<16)|(65536-AMP_OVER_2)};
487

gauthier's avatar
gauthier committed
488 489

#if defined(ENABLE_ITTI)
490
#   if ENABLE_RAL
gauthier's avatar
gauthier committed
491 492
extern PHY_MEASUREMENTS PHY_measurements;

493 494
void phy_eNB_lte_measurement_thresholds_test_and_report(instance_t instanceP, ral_threshold_phy_t* threshold_phy_pP, uint16_t valP)
{
495
  MessageDef *message_p = NULL;
496

497
  if (
498 499 500 501 502 503
    (
      ((threshold_phy_pP->threshold.threshold_val <  valP) && (threshold_phy_pP->threshold.threshold_xdir == RAL_ABOVE_THRESHOLD)) ||
      ((threshold_phy_pP->threshold.threshold_val >  valP) && (threshold_phy_pP->threshold.threshold_xdir == RAL_BELOW_THRESHOLD))
    )  ||
    (threshold_phy_pP->threshold.threshold_xdir == RAL_NO_THRESHOLD)
  ) {
504 505 506 507
    message_p = itti_alloc_new_message(TASK_PHY_ENB , PHY_MEAS_REPORT_IND);
    memset(&PHY_MEAS_REPORT_IND(message_p), 0, sizeof(PHY_MEAS_REPORT_IND(message_p)));

    memcpy(&PHY_MEAS_REPORT_IND (message_p).threshold,
508 509
           &threshold_phy_pP->threshold,
           sizeof(PHY_MEAS_REPORT_IND (message_p).threshold));
510 511

    memcpy(&PHY_MEAS_REPORT_IND (message_p).link_param,
512 513 514
           &threshold_phy_pP->link_param,
           sizeof(PHY_MEAS_REPORT_IND (message_p).link_param));
    \
515 516 517 518 519

    switch (threshold_phy_pP->link_param.choice) {
    case RAL_LINK_PARAM_CHOICE_LINK_PARAM_VAL:
      PHY_MEAS_REPORT_IND (message_p).link_param._union.link_param_val = valP;
      break;
520

521 522 523 524
    case RAL_LINK_PARAM_CHOICE_QOS_PARAM_VAL:
      //PHY_MEAS_REPORT_IND (message_p).link_param._union.qos_param_val.
      AssertFatal (1 == 0, "TO DO RAL_LINK_PARAM_CHOICE_QOS_PARAM_VAL\n");
      break;
525
    }
526

527 528
    itti_send_msg_to_task(TASK_RRC_ENB, instanceP, message_p);
  }
gauthier's avatar
gauthier committed
529 530
}

531 532
void phy_eNB_lte_check_measurement_thresholds(instance_t instanceP, ral_threshold_phy_t* threshold_phy_pP)
{
533 534 535 536 537 538 539 540 541 542 543
  unsigned int  mod_id;

  mod_id = instanceP;

  switch (threshold_phy_pP->link_param.link_param_type.choice) {

  case RAL_LINK_PARAM_TYPE_CHOICE_GEN:
    switch (threshold_phy_pP->link_param.link_param_type._union.link_param_gen) {
    case RAL_LINK_PARAM_GEN_DATA_RATE:
      phy_eNB_lte_measurement_thresholds_test_and_report(instanceP, threshold_phy_pP, 0);
      break;
544

545 546 547
    case RAL_LINK_PARAM_GEN_SIGNAL_STRENGTH:
      phy_eNB_lte_measurement_thresholds_test_and_report(instanceP, threshold_phy_pP, 0);
      break;
548

549 550 551
    case RAL_LINK_PARAM_GEN_SINR:
      phy_eNB_lte_measurement_thresholds_test_and_report(instanceP, threshold_phy_pP, 0);
      break;
552

553 554
    case RAL_LINK_PARAM_GEN_THROUGHPUT:
      break;
555

556 557
    case RAL_LINK_PARAM_GEN_PACKET_ERROR_RATE:
      break;
558 559 560

    default:
      ;
gauthier's avatar
gauthier committed
561
    }
562

563 564 565 566 567 568
    break;

  case RAL_LINK_PARAM_TYPE_CHOICE_LTE:
    switch (threshold_phy_pP->link_param.link_param_type._union.link_param_gen) {
    case RAL_LINK_PARAM_LTE_UE_RSRP:
      break;
569

570 571
    case RAL_LINK_PARAM_LTE_UE_RSRQ:
      break;
572

573 574
    case RAL_LINK_PARAM_LTE_UE_CQI:
      break;
575

576 577
    case RAL_LINK_PARAM_LTE_AVAILABLE_BW:
      break;
578

579 580
    case RAL_LINK_PARAM_LTE_PACKET_DELAY:
      break;
581

582 583
    case RAL_LINK_PARAM_LTE_PACKET_LOSS_RATE:
      break;
584

585 586
    case RAL_LINK_PARAM_LTE_L2_BUFFER_STATUS:
      break;
587

588 589
    case RAL_LINK_PARAM_LTE_MOBILE_NODE_CAPABILITIES:
      break;
590

591 592
    case RAL_LINK_PARAM_LTE_EMBMS_CAPABILITY:
      break;
593

594 595
    case RAL_LINK_PARAM_LTE_JUMBO_FEASIBILITY:
      break;
596

597 598
    case RAL_LINK_PARAM_LTE_JUMBO_SETUP_STATUS:
      break;
599

600 601
    case RAL_LINK_PARAM_LTE_NUM_ACTIVE_EMBMS_RECEIVERS_PER_FLOW:
      break;
602 603 604

    default:
      ;
605
    }
606

607 608
    break;

609 610
  default:
    ;
611
  }
gauthier's avatar
gauthier committed
612 613 614 615
}
#   endif
#endif

616 617


618
void phy_procedures_eNB_TX(unsigned char sched_subframe,PHY_VARS_eNB *phy_vars_eNB,uint8_t abstraction_flag,
619 620
                           relaying_type_t r_type,PHY_VARS_RN *phy_vars_rn)
{
621
  UNUSED(phy_vars_rn);
622 623
  uint8_t *pbch_pdu=&phy_vars_eNB->pbch_pdu[0];
  uint16_t input_buffer_length, re_allocated=0;
624
  uint32_t i,aa;
625
  uint8_t harq_pid;
626
  DCI_PDU *DCI_pdu;
627
  uint8_t *DLSCH_pdu=NULL;
628
  DCI_PDU DCI_pdu_tmp;
629 630 631 632 633
  uint8_t DLSCH_pdu_tmp[768*8];
  int8_t UE_id;
  uint8_t num_pdcch_symbols=0;
  uint8_t ul_subframe;
  uint32_t ul_frame;
634
#ifdef Rel10
635 636
  MCH_PDU *mch_pduP;
  MCH_PDU  mch_pdu;
637
  //  uint8_t sync_area=255;
638 639 640 641
#endif
#if defined(SMBV) && !defined(EXMIMO)
  // counts number of allocations in subframe
  // there is at least one allocation for PDCCH
642
  uint8_t smbv_alloc_cnt = 1;
643
#endif
644
  int frame = phy_vars_eNB->proc[sched_subframe].frame_tx;
645
  int subframe = phy_vars_eNB->proc[sched_subframe].subframe_tx;
646

gauthier's avatar
gauthier committed
647
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_TX,1);
648
  start_meas(&phy_vars_eNB->phy_proc_tx);
649

650
#ifdef DEBUG_PHY_PROC
651
  LOG_D(PHY,"[%s %"PRIu8"] Frame %d subframe %d : Doing phy_procedures_eNB_TX\n",
652 653
        (r_type == multicast_relay) ? "RN/eNB" : "eNB",
        phy_vars_eNB->Mod_id, frame, subframe);
654
#endif
655

656 657
  T(T_ENB_DL_TICK, T_INT(phy_vars_eNB->Mod_id), T_INT(frame), T_INT(subframe));

658
  for (i=0; i<NUMBER_OF_UE_MAX; i++) {
659 660 661
    // If we've dropped the UE, go back to PRACH mode for this UE
    //#if !defined(EXMIMO_IOT)
    if (phy_vars_eNB->eNB_UE_stats[i].ulsch_consecutive_errors == ULSCH_max_consecutive_errors) {
662
      LOG_W(PHY,"[eNB %d, CC %d] frame %d, subframe %d, UE %d: ULSCH consecutive error count reached %u, removing UE\n",
663 664 665 666
            phy_vars_eNB->Mod_id,phy_vars_eNB->CC_id,frame,subframe, i, phy_vars_eNB->eNB_UE_stats[i].ulsch_consecutive_errors);
      phy_vars_eNB->eNB_UE_stats[i].mode = PRACH;
      remove_ue(phy_vars_eNB->eNB_UE_stats[i].crnti,phy_vars_eNB,abstraction_flag);
      phy_vars_eNB->eNB_UE_stats[i].ulsch_consecutive_errors=0;
667
    }
668

669 670 671 672
    //#endif
  }


673
  // Get scheduling info for next subframe
674 675 676 677 678
  if (phy_vars_eNB->mac_enabled==1) {
    if (phy_vars_eNB->CC_id == 0) {
      mac_xface->eNB_dlsch_ulsch_scheduler(phy_vars_eNB->Mod_id,0,phy_vars_eNB->proc[sched_subframe].frame_tx,subframe);//,1);
    }
  }
679

680
  if (abstraction_flag==0) {
681
    // clear the transmit data array for the current subframe
682 683
    for (aa=0; aa<phy_vars_eNB->lte_frame_parms.nb_antennas_tx_eNB; aa++) {

684
      memset(&phy_vars_eNB->lte_eNB_common_vars.txdataF[0][aa][subframe*phy_vars_eNB->lte_frame_parms.ofdm_symbol_size*(phy_vars_eNB->lte_frame_parms.symbols_per_tti)],
685
             0,phy_vars_eNB->lte_frame_parms.ofdm_symbol_size*(phy_vars_eNB->lte_frame_parms.symbols_per_tti)*sizeof(mod_sym_t));
686 687
    }
  }
688 689


690
  if (is_pmch_subframe(phy_vars_eNB->proc[sched_subframe].frame_tx,subframe,&phy_vars_eNB->lte_frame_parms)) {
691

692
    if (abstraction_flag==0) {
693 694
      // This is DL-Cell spec pilots in Control region
      generate_pilots_slot(phy_vars_eNB,
695 696 697
                           phy_vars_eNB->lte_eNB_common_vars.txdataF[0],
                           AMP,
                           subframe<<1,1);
698
    }
699

700
#ifdef Rel10
701
    // if mcch is active, send regardless of the node type: eNB or RN
702
    // when mcch is active, MAC sched does not allow MCCH and MTCH multiplexing
703
    mch_pduP = mac_xface->get_mch_sdu(phy_vars_eNB->Mod_id,
704 705 706 707 708
                                      phy_vars_eNB->CC_id,
                                      phy_vars_eNB->proc[sched_subframe].frame_tx,
                                      subframe);

    switch (r_type) {
709
    case no_relay:
710
      if ((mch_pduP->Pdu_size > 0) && (mch_pduP->sync_area == 0)) // TEST: only transmit mcch for sync area 0
711
        LOG_I(PHY,"[eNB%"PRIu8"] Frame %d subframe %d : Got MCH pdu for MBSFN (MCS %"PRIu8", TBS %d) \n",
712 713
              phy_vars_eNB->Mod_id,phy_vars_eNB->proc[sched_subframe].frame_tx,subframe,mch_pduP->mcs,
              phy_vars_eNB->dlsch_eNB_MCH->harq_processes[0]->TBS>>3);
714
      else {
715
        LOG_D(PHY,"[DeNB %"PRIu8"] Frame %d subframe %d : Do not transmit MCH pdu for MBSFN sync area %"PRIu8" (%s)\n",
716 717 718
              phy_vars_eNB->Mod_id,phy_vars_eNB->proc[sched_subframe].frame_tx,subframe,mch_pduP->sync_area,
              (mch_pduP->Pdu_size == 0)? "Empty MCH PDU":"Let RN transmit for the moment");
        mch_pduP = NULL;
719
      }
720

721
      break;
722

723
    case multicast_relay:
724
      if ((mch_pduP->Pdu_size > 0) && ((mch_pduP->mcch_active == 1) || mch_pduP->msi_active==1)) {
725
        LOG_I(PHY,"[RN %"PRIu8"] Frame %d subframe %d: Got the MCH PDU for MBSFN  sync area %"PRIu8" (MCS %"PRIu8", TBS %"PRIu16")\n",
726 727 728 729 730 731 732 733 734
              phy_vars_rn->Mod_id,phy_vars_rn->frame, subframe,
              mch_pduP->sync_area,mch_pduP->mcs,mch_pduP->Pdu_size);
      } else if (phy_vars_rn->mch_avtive[subframe%5] == 1) { // SF2 -> SF7, SF3 -> SF8
        mch_pduP= &mch_pdu;
        memcpy(&mch_pduP->payload, // could be a simple copy
               phy_vars_rn->dlsch_rn_MCH[subframe%5]->harq_processes[0]->b,
               phy_vars_rn->dlsch_rn_MCH[subframe%5]->harq_processes[0]->TBS>>3);
        mch_pduP->Pdu_size = (uint16_t) (phy_vars_rn->dlsch_rn_MCH[subframe%5]->harq_processes[0]->TBS>>3);
        mch_pduP->mcs = phy_vars_rn->dlsch_rn_MCH[subframe%5]->harq_processes[0]->mcs;
735
        LOG_I(PHY,"[RN %"PRIu8"] Frame %d subframe %d: Forward the MCH PDU for MBSFN received on SF %d sync area %"PRIu8" (MCS %"PRIu8", TBS %"PRIu16")\n",
736 737
              phy_vars_rn->Mod_id,phy_vars_rn->frame, subframe,subframe%5,
              phy_vars_rn->sync_area[subframe%5],mch_pduP->mcs,mch_pduP->Pdu_size);
738
      } else {
739 740 741 742
        /* LOG_I(PHY,"[RN %d] Frame %d subframe %d: do not forward MCH pdu for MBSFN  sync area %d (MCS %d, TBS %d)\n",
           phy_vars_rn->Mod_id,phy_vars_rn->frame, next_slot>>1,
           mch_pduP->sync_area,mch_pduP->mcs,mch_pduP->Pdu_size);*/
        mch_pduP=NULL;
743
      }
744

745 746
      phy_vars_rn->mch_avtive[subframe]=0;
      break;
747

748
    default:
749
      LOG_W(PHY,"[eNB %"PRIu8"] Frame %d subframe %d: unknown relaying type %d \n",
750
            phy_vars_eNB->Mod_id,phy_vars_eNB->proc[sched_subframe].frame_tx,subframe,r_type);
751 752
      mch_pduP=NULL;
      break;
753 754 755
    }// switch

    if (mch_pduP) {
756 757
      fill_eNB_dlsch_MCH(phy_vars_eNB,mch_pduP->mcs,1,0, abstraction_flag);
      // Generate PMCH
758
      generate_mch(phy_vars_eNB,sched_subframe,(uint8_t*)mch_pduP->payload,abstraction_flag);
759
#ifdef DEBUG_PHY
760 761

      for (i=0; i<mch_pduP->Pdu_size; i++)
762
        msg("%2"PRIx8".",(uint8_t)mch_pduP->payload[i]);
763

764
      msg("\n");
765
#endif
766 767
    } else {
      LOG_D(PHY,"[eNB/RN] Frame %d subframe %d: MCH not generated \n",phy_vars_eNB->proc[sched_subframe].frame_tx,subframe);
768
    }
769

770 771
#endif
  }
772

773
  else {
774
    // this is not a pmch subframe
775 776

    if (abstraction_flag==0) {
gauthier's avatar
gauthier committed
777
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_RS_TX,1);
778
      generate_pilots_slot(phy_vars_eNB,
779 780 781
                           phy_vars_eNB->lte_eNB_common_vars.txdataF[0],
                           AMP,
                           subframe<<1,0);
782 783 784 785 786 787
      if (subframe_select(&phy_vars_eNB->lte_frame_parms,subframe) == SF_DL)
	generate_pilots_slot(phy_vars_eNB,
			     phy_vars_eNB->lte_eNB_common_vars.txdataF[0],
			     AMP,
			     (subframe<<1)+1,0);

gauthier's avatar
gauthier committed
788
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_RS_TX,0);
789

790 791
      // First half of PSS/SSS (FDD)
      if (subframe == 0) {
792 793
        if (phy_vars_eNB->lte_frame_parms.frame_type == FDD) {
          generate_pss(phy_vars_eNB->lte_eNB_common_vars.txdataF[0],
794
                       AMP,
795
                       &phy_vars_eNB->lte_frame_parms,
796
                       (phy_vars_eNB->lte_frame_parms.Ncp==NORMAL) ? 6 : 5,
797 798
                       0);
          generate_sss(phy_vars_eNB->lte_eNB_common_vars.txdataF[0],
799
                       AMP,
800
                       &phy_vars_eNB->lte_frame_parms,
801
                       (phy_vars_eNB->lte_frame_parms.Ncp==NORMAL) ? 5 : 4,
802 803 804 805
                       0);

        }
      }
806
    }
807
  }
808

809
  if (subframe == 0) {
810
    // generate PBCH (Physical Broadcast CHannel) info
811
    if ((phy_vars_eNB->proc[sched_subframe].frame_tx&3) == 0) {
812
      pbch_pdu[2] = 0;
813

814
      // FIXME setting pbch_pdu[2] to zero makes the switch statement easier: remove all the or-operators
815 816
      switch (phy_vars_eNB->lte_frame_parms.N_RB_DL) {
      case 6:
817
        pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (0<<5);
818 819
        break;

820
      case 15:
821
        pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (1<<5);
822 823
        break;

824
      case 25:
825
        pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (2<<5);
826 827
        break;

828
      case 50:
829
        pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (3<<5);
830 831
        break;

832
      case 75:
833
        pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (4<<5);
834 835
        break;

836
      case 100:
837
        pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (5<<5);
838 839
        break;

840
      default:
841 842
        // FIXME if we get here, this should be flagged as an error, right?
        pbch_pdu[2] = (pbch_pdu[2]&0x1f) | (2<<5);
843
        break;
844
      }
845

846
      pbch_pdu[2] = (pbch_pdu[2]&0xef) |
847 848
                    ((phy_vars_eNB->lte_frame_parms.phich_config_common.phich_duration << 4)&0x10);

849 850
      switch (phy_vars_eNB->lte_frame_parms.phich_config_common.phich_resource) {
      case oneSixth:
851
        pbch_pdu[2] = (pbch_pdu[2]&0xf3) | (0<<2);
852 853
        break;

854
      case half:
855
        pbch_pdu[2] = (pbch_pdu[2]&0xf3) | (1<<2);
856 857
        break;

858
      case one:
859
        pbch_pdu[2] = (pbch_pdu[2]&0xf3) | (2<<2);
860 861
        break;

862
      case two:
863
        pbch_pdu[2] = (pbch_pdu[2]&0xf3) | (3<<2);
864 865
        break;

866
      default:
867
        // unreachable
868
        break;
869
      }
870

871 872 873
      pbch_pdu[2] = (pbch_pdu[2]&0xfc) | ((phy_vars_eNB->proc[sched_subframe].frame_tx>>8)&0x3);
      pbch_pdu[1] = phy_vars_eNB->proc[sched_subframe].frame_tx&0xfc;
      pbch_pdu[0] = 0;
874
    }
875

876 877
    /// First half of SSS (TDD)
    if (abstraction_flag==0) {
878

879
      if (phy_vars_eNB->lte_frame_parms.frame_type == TDD) {
880 881 882
        generate_sss(phy_vars_eNB->lte_eNB_common_vars.txdataF[0],
                     AMP,
                     &phy_vars_eNB->lte_frame_parms,
883
                     (phy_vars_eNB->lte_frame_parms.Ncp==NORMAL) ? 6 : 5,
884
                     1);
885
      }
886
    }
887 888


889 890


891
#ifdef DEBUG_PHY_PROC
892 893 894
    uint16_t frame_tx = (((int) (pbch_pdu[2]&0x3))<<8) + ((int) (pbch_pdu[1]&0xfc)) + phy_vars_eNB->proc[sched_subframe].frame_tx%4;

    LOG_D(PHY,"[eNB %"PRIu8"] Frame %d, subframe %d: Generating PBCH, mode1_flag=%"PRIu8", frame_tx=%"PRIu16", pdu=%02"PRIx8"%02"PRIx8"%02"PRIx8"\n",
895 896 897 898 899
          phy_vars_eNB->Mod_id,
          phy_vars_eNB->proc[sched_subframe].frame_tx,
          subframe,
          phy_vars_eNB->lte_frame_parms.mode1_flag,
          frame_tx,
900 901 902
          pbch_pdu[2],
          pbch_pdu[1],
          pbch_pdu[0]);
903
#endif
904

905
    if (abstraction_flag==0) {
906

907
      generate_pbch(&phy_vars_eNB->lte_eNB_pbch,
908 909 910 911 912 913
                    phy_vars_eNB->lte_eNB_common_vars.txdataF[0],
                    AMP,
                    &phy_vars_eNB->lte_frame_parms,
                    pbch_pdu,
                    phy_vars_eNB->proc[sched_subframe].frame_tx&3);

914
    }
915

916
#ifdef PHY_ABSTRACTION
917
    else {
918
      generate_pbch_emul(phy_vars_eNB,pbch_pdu);