dlsim execution

Conflicts:
	openair1/PHY/LTE_TRANSPORT/pmch.c
	openair1/PHY/LTE_TRANSPORT/transport_proto.h
	openair1/PHY/MODULATION/beamforming.c
	openair1/PHY/TOOLS/lte_dfts.c
	openair1/SCHED/phy_procedures_lte_eNb.c
	openair1/SCHED_UE/phy_procedures_lte_ue.c

cmake_targets/lte-simulators/CMakeLists.txt

@@ -1,4 +1,5 @@
 cmake_minimum_required(VERSION 2.8)
+set(RRC_ASN1_VERSION "Rel14")
 set(PACKAGE_NAME "unitary_tests_simulators")
 set(PHYSIM True)
 set(RF_BOARD None)

common/config/config_load_configmodule.c

@@ -248,8 +248,11 @@ int i;
 
    
    printf("[CONFIG] get parameters from %s ",cfgmode);
+
+
+		
    for (i=0;i<cfgptr->num_cfgP; i++) {
-        printf("%s ",cfgptr->cfgP[i]); 
+   printf("%s ",cfgptr->cfgP[i]); 
    }
    printf(", debug flags: 0x%08x\n",cfgptr->rtflags);
 
@@ -270,8 +273,18 @@ int i;
       cfgptr->end = (configmodule_endfunc_t)nooptfunc;
    }
 
-  
-
+	/*
+	//(IRTBL_start) just debugging tests
+	printf("\x1B[32m");
+	printf("\n\n\n[IRTBL] Function called *load_configmodule in config_load_configmodule.c\n\n\n");
+	printf("\x1B[0m");
+	//getchar();
+	printf("[IRTBL] Trying to terminate oaisim\n");
+	system("sudo killall oaisim_nos1");
+	//(IRTBL_end) just debugging tests
+        */
+   
+   
    if (modeparams != NULL) free(modeparams);
    if (cfgmode != NULL) free(cfgmode);
    if (CONFIG_ISFLAGSET(CONFIG_ABORT)) {
@@ -319,6 +332,9 @@ void free_configmodule(void)
   free(cfgptr);
   cfgptr=NULL;
   }
+   
+
+   
 }
 
 

openair1/PHY/CODING/lte_rate_matching.c

@@ -86,19 +86,6 @@ uint32_t sub_block_interleaving_turbo(uint32_t D, uint8_t *d,uint8_t *w)
       w[Kpi+1+k2]     =  d3[index3];//d[index3-ND3+5];
 
 
-#ifdef RM_DEBUG
-      printf("row %d, index %d, index-Nd %d index-Nd+1 %d (k,Kpi+2k,Kpi+2k+1) (%d,%d,%d) w(%d,%d,%d)\n",row,index,index-ND,((index+1)%Kpi)-ND,k,Kpi+(k<<1),Kpi+(k<<1)+1,w[k],w[Kpi+(k<<1)],w[Kpi+1+(k<<1)]);
-
-      if (w[k]== LTE_NULL)
-        nulled++;
-
-      if (w[Kpi+(k<<1)] ==LTE_NULL)
-        nulled++;
-
-      if (w[Kpi+1+(k<<1)] ==LTE_NULL)
-        nulled++;
-
-#endif
       index3+=96;
       k++;k2+=2;
     }
@@ -706,11 +693,9 @@ int lte_rate_matching_turbo_rx(uint32_t RTC,
   int nulled=0;
 #endif
 
-  if (Kmimo==0 || C==0 || Qm==0 || Nl==0) {
-    printf("lte_rate_matching.c: invalid parameters (Kmimo %d, Mdlharq %d, C %d, Qm %d, Nl %d\n",
-        Kmimo,Mdlharq,C,Qm,Nl);
-    return(-1);
-  }
+  AssertFatal(Kmimo>0 && C>0 && (Qm==2 || Qm==4 || Qm==6) && Nl>0 && Mdlharq>=0, 
+	      "invalid parameters (Kmimo %d, Mdlharq %d, C %d, Qm %d, Nl %d\n",
+	      Kmimo,Mdlharq,C,Qm,Nl);
 
   if (Mdlharq>0) { // Downlink
     Nir = Nsoft/Kmimo/cmin(8,Mdlharq);
@@ -721,8 +706,6 @@ int lte_rate_matching_turbo_rx(uint32_t RTC,
     Ncb = 3*(RTC<<5);
   }
 
-  AssertFatal(Nl>0,"Nl is 0\n");
-  AssertFatal(Qm>0,"Qm is 0\n");
   Gp = G/Nl/Qm;
   GpmodC = Gp%C;
 

openair1/PHY/INIT/lte_init.c

@@ -784,7 +784,7 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
   LOG_I(PHY,"[INIT] NB_ANTENNA_PORTS_ENB:%d fp->nb_antenna_ports_eNB:%d\n", NB_ANTENNA_PORTS_ENB, fp->nb_antenna_ports_eNB);
 
   for (i=0; i<NB_ANTENNA_PORTS_ENB; i++) {
-    if (i<fp->nb_antenna_ports_eNB || i==5) {
+    if (i<fp->nb_antenna_ports_eNB || i==4 || i==5 || i==7 || i==8) {
       common_vars->txdataF[i] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t) );
       
       LOG_I(PHY,"[INIT] common_vars->txdataF[%d] = %p (%lu bytes)\n",

openair1/PHY/INIT/lte_init_ru.c

@@ -120,7 +120,7 @@ int phy_init_RU(RU_t *ru) {
     for (i=0; i<RC.nb_L1_inst; i++) {
       for (p=0;p<15;p++) {
         LOG_D(PHY,"[INIT] %s() nb_antenna_ports_eNB:%d \n", __FUNCTION__, ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB);
-	if (p<ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB || p==5) {
+	if (p<ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB || p==4 || p==5) {
           LOG_D(PHY,"[INIT] %s() DO BEAM WEIGHTS nb_antenna_ports_eNB:%d nb_tx:%d\n", __FUNCTION__, ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB, ru->nb_tx);
 	  ru->beam_weights[i][p] = (int32_t **)malloc16_clear(ru->nb_tx*sizeof(int32_t*));
 	  for (j=0; j<ru->nb_tx; j++) {

openair1/PHY/INIT/lte_parms.c

@@ -44,17 +44,28 @@ int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf)
 
   uint8_t log2_osf;
 
-#if DISABLE_LOG_X
+// [IRTGS 20180611: Output disabled temporarily]
+/*#if DISABLE_LOG_X
   printf("Initializing frame parms for N_RB_DL %d, Ncp %d, osf %d\n",frame_parms->N_RB_DL,frame_parms->Ncp,osf);
 #else
   LOG_I(PHY,"Initializing frame parms for N_RB_DL %d, Ncp %d, osf %d\n",frame_parms->N_RB_DL,frame_parms->Ncp,osf);
 #endif
-
+*/
   if (frame_parms->Ncp==EXTENDED) {
+        //(IRTBL_start) just debugging tests
+        //printf("\x1B[32m");
+        //printf("[IRTBL] EXTENDED CP detected\n");
+        //printf("\x1B[0m");
+        //(IRTBL_end) just debugging tests
     frame_parms->nb_prefix_samples0=512;
     frame_parms->nb_prefix_samples = 512;
     frame_parms->symbols_per_tti = 12;
   } else {
+        //(IRTBL_start) just debugging tests
+        //printf("\x1B[32m");
+        //printf("[IRTBL] NORMAL CP detected\n");
+        //printf("\x1B[0m");
+        //(IRTBL_end) just debugging tests
     frame_parms->nb_prefix_samples0 = 160;
     frame_parms->nb_prefix_samples = 144;
     frame_parms->symbols_per_tti = 14;

openair1/PHY/LTE_ESTIMATION/lte_adjust_sync.c

@@ -121,6 +121,10 @@ void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms,
       if ( ue->rx_offset >= FRAME_LENGTH_COMPLEX_SAMPLES )
           ue->rx_offset -= FRAME_LENGTH_COMPLEX_SAMPLES;
 
+// [IRTGS 20180614] just for testing...
+// printf("\x1B[1;34m[IRTGS]: \x1B[0m"); // blue
+// printf("\x1B[32m%s %d\x1B[0m\n","lte_adjust_sync(): ue->rx_offset = ",ue->rx_offset);
+
 
 
       #ifdef DEBUG_PHY

openair1/PHY/LTE_ESTIMATION/lte_sync_time.c

@@ -349,6 +349,11 @@ int lte_sync_time(int **rxdata, ///rx data in time domain
   int tmp[3] = {0,0,0};
   int length =   LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*frame_parms->samples_per_tti>>1;
 
+// [IRTGS 20180615] variables for determining a qualtiy indicator
+  unsigned int QI;
+  unsigned long cnt=0, cum_sum[3];
+  for (int ii=0;ii<=2;cum_sum[ii++] = 0);
+
   //LOG_D(PHY,"[SYNC TIME] Calling sync_time.\n");
   AssertFatal(sync_corr_ue0 != NULL,
              "sync_corr_ue0 not yet allocated! Exiting.\n");
@@ -361,6 +366,12 @@ int lte_sync_time(int **rxdata, ///rx data in time domain
   peak_pos = 0;
   sync_source = 0;
 
+        //printf("\x1B[32m");
+        //printf("\n\n\n\n[IRTBL] \n\n\n");
+        //printf("peak_pos = %d\n sync_source = %d\n should be a value\n",peak_pos,sync_source);
+        //printf("\x1B[0m");
+
+
 
   for (n=0; n<length; n+=4) {
 
@@ -434,21 +445,39 @@ int lte_sync_time(int **rxdata, ///rx data in time domain
     sync_corr_ue2[n] = abs32(sync_corr_ue2[n]);
     sync_corr_ue2[n+length] = abs32(sync_corr_ue2[n+length]);
 
+// [IRTGS 20180615] quality indicator
+    cnt++;
+
     for (s=0; s<3; s++) {
       tmp[s] = (abs32(sync_out[s])>>1) + (abs32(sync_out2[s])>>1);
 
+// [IRTGS 20180615] quality indicator
+      cum_sum[s] += tmp[s];
+
       if (tmp[s]>peak_val) {
         peak_val = tmp[s];
         peak_pos = n;
         sync_source = s;
-        /*
+       /*
         printf("s %d: n %d sync_out %d, sync_out2  %d (sync_corr %d,%d), (%d,%d) (%d,%d)\n",s,n,abs32(sync_out[s]),abs32(sync_out2[s]),sync_corr_ue0[n],
                sync_corr_ue0[n+length],((int16_t*)&sync_out[s])[0],((int16_t*)&sync_out[s])[1],((int16_t*)&sync_out2[s])[0],((int16_t*)&sync_out2[s])[1]);
-        */
+       */
       }
     }
   }
 
+// [IRTGS 20180618] quality indicator
+  printf("\x1B[1;34m[IRTGS]: \x1B[0m"); // blue
+  // let's assume that the peak_value should be at least 5 times the average value...
+  QI = (8*cum_sum[sync_source]<cnt*peak_val) ? 1:0;  
+  if (QI == 1)
+    printf("\x1B[32m%s \x1B[0m","lte_sync_time(): QI: ok  ");
+  else
+    printf("\x1B[1;31m%s \x1B[0m","lte_sync_time(): QI: not ok  ");
+
+  printf("\x1B[32m%s%ld %s%ld\x1B[0m\n","cnt*peak_val = ",cnt*peak_val,"  cum_sum = ",cum_sum[sync_source]);
+  if (QI==0) return -1; // indicates here, that sync peak is not high enough...
+  
   *eNB_id = sync_source;
 
   LOG_I(PHY,"[UE] lte_sync_time: Sync source = %d, Peak found at pos %d, val = %d (%d dB)\n",sync_source,peak_pos,peak_val,dB_fixed(peak_val)/2);
@@ -467,7 +496,14 @@ int lte_sync_time(int **rxdata, ///rx data in time domain
   }
 } 
 
-
+	//printf("\x1B[32m");
+	//printf("\n\n\n\n[IRTBL] \n\n\n");
+	//printf("sync_source = %d    peak_pos = %d\n",sync_source, peak_pos);        
+	//printf("peak_pos  = %d\n",peak_pos);
+        //printf("eNB_id = %d\n",*eNB_id);
+        //printf("\x1B[0m");
+//printf("[IRTBL] Trying to terminate oai\n");
+//system("sudo killall lte-uesoftmodem-nos1");
   return(peak_pos);
 
 }

openair1/PHY/LTE_REFSIG/lte_dl_mbsfn.c

@@ -29,6 +29,7 @@
 #include "PHY/defs_UE.h"
 #include "PHY/impl_defs_top.h"
 
+
 //extern unsigned int lte_gold_table[10][3][42];
 //#define DEBUG_DL_MBSFN
 
@@ -154,3 +155,129 @@ int lte_dl_mbsfn_rx(PHY_VARS_UE *ue,
   return(0);
 }
 
+
+// [IRTGS 20180727] added lte_dl_mbsfn125() and lte_Dl_mbsfn125_rx() for df = 1.25 kHz
+// see TS 136.211 ch.6.10.2.1.2 and 6.10.2.2.2
+
+int lte_dl_mbsfn125(PHY_VARS_eNB *eNB, int32_t *output,
+                 short amp,
+                 int subframe) // only l=0 possible for df=1.25 kHz 
+{
+
+  unsigned int mprime,mprime_dword,mprime_qpsk_symb,m;
+  unsigned short k=0,a;
+  int32_t qpsk[4];
+
+  a = (amp*ONE_OVER_SQRT2_Q15)>>15;
+  ((short *)&qpsk[0])[0] = a;
+  ((short *)&qpsk[0])[1] = a;
+
+  ((short *)&qpsk[1])[0] = -a;
+  ((short *)&qpsk[1])[1] = a;
+  ((short *)&qpsk[2])[0] = a;
+  ((short *)&qpsk[2])[1] = -a;
+
+  ((short *)&qpsk[3])[0] = -a;
+  ((short *)&qpsk[3])[1] = -a;
+
+
+  mprime = 3*(110 - eNB->frame_parms.N_RB_DL);
+
+  for (m=0; m<eNB->frame_parms.N_RB_DL*24; m++) // m = 0:24*N_RB_DL-1
+    { 
+      if ((subframe&0x1)==0) // n_sf mod 2 == 0: even 
+	k = 6*m;
+      else 
+	k = 6*m + 3;
+      
+      
+      k+=eNB->frame_parms.first_carrier_offset;
+      
+      mprime_dword     = mprime>>4;
+      mprime_qpsk_symb = mprime&0xf;
+      
+      if (k >= eNB->frame_parms.ofdm_symbol_size) {
+	k++;  // skip DC carrier
+	k-=eNB->frame_parms.ofdm_symbol_size;
+      }
+      
+      // lte_gold_mbsfn125_table needs to be generated.
+      // for MBMS this is done in openair1/PHY/INIT/lte_init.c → phy_config_sib13_eNB():  
+      // lte_gold_mbsfn(fp,RC.eNB[Mod_id][CC_id]->lte_gold_mbsfn_table,fp->Nid_cell_mbsfn);
+      output[k] = qpsk[(eNB->lte_gold_mbsfn125_table[subframe][mprime_dword]>>(2*mprime_qpsk_symb))&3];
+      
+      //output[k] = qpsk[(eNB->lte_gold_mbsfn_table[subframe][l][mprime_dword]>>(2*mprime_qpsk_symb))&3];
+      
+#ifdef DEBUG_DL_MBSFN
+      LOG_D(PHY,"subframe %d, (l=0,) m %d, mprime %d, mprime_dword %d, mprime_qpsk_symbol %d\n",
+	    subframe,m,mprime,mprime_dword,mprime_qpsk_symb);
+      LOG_D(PHY,"index = %d (k %d)(%x)\n",(eNB->lte_gold_mbsfn125_table[subframe][mprime_dword]>>(2*mprime_qpsk_symb))&3,k,eNB->lte_gold_mbsfn125_table[subframe][mprime_dword]);
+#endif
+      mprime++;
+      
+#ifdef DEBUG_DL_MBSFN
+      
+      if (m<18)
+	printf("subframe %d, (l=0) output[%d] = (%d,%d)\n",subframe,k,((short *)&output[k])[0],((short *)&output[k])[1]);
+      
+#endif
+      
+    }
+  
+  return(0);
+}
+
+
+int lte_dl_mbsfn125_rx(PHY_VARS_UE *ue,
+                    int *output,
+                    int subframe) // l=0 for df = 1.25 kHz
+{
+
+  unsigned int mprime,mprime_dword,mprime_qpsk_symb,m;
+  unsigned short k=0;
+  unsigned int qpsk[4];
+
+  // This includes complex conjugate for channel estimation
+
+  ((short *)&qpsk[0])[0] = ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[0])[1] = -ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[1])[0] = -ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[1])[1] = -ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[2])[0] = ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[2])[1] = ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[3])[0] = -ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[3])[1] = ONE_OVER_SQRT2_Q15;
+
+  mprime = 3*(110 - ue->frame_parms.N_RB_DL);
+
+  for (m=0; m<ue->frame_parms.N_RB_DL*24; m++) // m = 0:24*N_RB_DL-1
+  { mprime_dword     = mprime>>4;
+    mprime_qpsk_symb = mprime&0xf;
+
+    // this is r_mprime from 3GPP 36-211 6.10.1.2
+    // lte_gold_mbsfn125_table needs to be generated.
+    // for MBMS this is done in openair1/PHY/INIT/lte_init_ue.c → phy_config_sib13_ue():  
+    // lte_gold_mbsfn(fp,PHY_vars_UE_g[Mod_id][CC_id]->lte_gold_mbsfn_table,fp->Nid_cell_mbsfn);
+    output[k] = qpsk[(ue->lte_gold_mbsfn125_table[subframe][mprime_dword]>>(2*mprime_qpsk_symb))&3];
+
+#ifdef DEBUG_DL_MBSFN
+    printf("subframe %d, (l=0), m %d, mprime %d, mprime_dword %d, mprime_qpsk_symbol %d\n",
+           subframe,m,mprime, mprime_dword,mprime_qpsk_symb);
+    printf("index = %d (k %d) (%x)\n",(ue->lte_gold_mbsfn125_table[subframe][mprime_dword]>>(2*mprime_qpsk_symb))&3,k,ue->lte_gold_mbsfn125_table[subframe][mprime_dword]);
+#endif
+
+    mprime++;
+#ifdef DEBUG_DL_MBSFN
+
+    if (m<18)
+      printf("subframe %d l 0 output[%d] = (%d,%d)\n",subframe,k,((short *)&output[k])[0],((short *)&output[k])[1]);
+
+#endif
+    k++;
+
+  }
+
+  return(0);
+}
+
+

openair1/PHY/LTE_REFSIG/lte_dl_mbsfn.c.bak

@@ -0,0 +1,154 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+// 6.10.2.2 MBSFN reference signals Mapping to resource elements
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "defs.h"
+#include "PHY/defs.h"
+
+//extern unsigned int lte_gold_table[10][3][42];
+//#define DEBUG_DL_MBSFN
+
+int lte_dl_mbsfn(PHY_VARS_eNB *eNB, int32_t *output,
+                 short amp,
+                 int subframe,
+                 unsigned char l)
+{
+
+  unsigned int mprime,mprime_dword,mprime_qpsk_symb,m;
+  unsigned short k=0,a;
+  int32_t qpsk[4];
+
+  a = (amp*ONE_OVER_SQRT2_Q15)>>15;
+  ((short *)&qpsk[0])[0] = a;
+  ((short *)&qpsk[0])[1] = a;
+
+  ((short *)&qpsk[1])[0] = -a;
+  ((short *)&qpsk[1])[1] = a;
+  ((short *)&qpsk[2])[0] = a;
+  ((short *)&qpsk[2])[1] = -a;
+
+  ((short *)&qpsk[3])[0] = -a;
+  ((short *)&qpsk[3])[1] = -a;
+
+
+  mprime = 3*(110 - eNB->frame_parms.N_RB_DL);
+
+  for (m=0; m<eNB->frame_parms.N_RB_DL*6; m++) {
+
+    if ((l==0) || (l==2))
+      k = m<<1;
+    else if (l==1)
+      k = 1+(m<<1);
+    else {
+      LOG_E(PHY,"lte_dl_mbsfn: l %d -> ERROR\n",l);
+      return(-1);
+    }
+
+    k+=eNB->frame_parms.first_carrier_offset;
+
+    mprime_dword     = mprime>>4;
+    mprime_qpsk_symb = mprime&0xf;
+
+    if (k >= eNB->frame_parms.ofdm_symbol_size) {
+      k++;  // skip DC carrier
+      k-=eNB->frame_parms.ofdm_symbol_size;
+    }
+
+    output[k] = qpsk[(eNB->lte_gold_mbsfn_table[subframe][l][mprime_dword]>>(2*mprime_qpsk_symb))&3];
+    //output[k] = (lte_gold_table[eNB_offset][subframe][l][mprime_dword]>>(2*mprime_qpsk_symb))&3;
+
+
+#ifdef DEBUG_DL_MBSFN
+    LOG_D(PHY,"subframe %d, l %d, m %d, mprime %d, mprime_dword %d, mprime_qpsk_symbol %d\n",
+        subframe,l,m,mprime,mprime_dword,mprime_qpsk_symb);
+    LOG_D(PHY,"index = %d (k %d)(%x)\n",(eNB->lte_gold_mbsfn_table[subframe][l][mprime_dword]>>(2*mprime_qpsk_symb))&3,k,eNB->lte_gold_mbsfn_table[subframe][l][mprime_dword]);
+#endif
+    mprime++;
+
+#ifdef DEBUG_DL_MBSFN
+
+    if (m<18)
+      printf("subframe %d, l %d output[%d] = (%d,%d)\n",subframe,l,k,((short *)&output[k])[0],((short *)&output[k])[1]);
+
+#endif
+
+  }
+
+  return(0);
+}
+
+
+
+int lte_dl_mbsfn_rx(PHY_VARS_UE *ue,
+                    int *output,
+                    int subframe,
+                    unsigned char l)
+{
+
+  unsigned int mprime,mprime_dword,mprime_qpsk_symb,m;
+  unsigned short k=0;
+  unsigned int qpsk[4];
+
+  // This includes complex conjugate for channel estimation
+
+  ((short *)&qpsk[0])[0] = ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[0])[1] = -ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[1])[0] = -ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[1])[1] = -ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[2])[0] = ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[2])[1] = ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[3])[0] = -ONE_OVER_SQRT2_Q15;
+  ((short *)&qpsk[3])[1] = ONE_OVER_SQRT2_Q15;
+
+  mprime = 3*(110 - ue->frame_parms.N_RB_DL);
+
+  for (m=0; m<ue->frame_parms.N_RB_DL*6; m++) {
+
+    mprime_dword     = mprime>>4;
+    mprime_qpsk_symb = mprime&0xf;
+
+    // this is r_mprime from 3GPP 36-211 6.10.1.2
+    output[k] = qpsk[(ue->lte_gold_mbsfn_table[subframe][l][mprime_dword]>>(2*mprime_qpsk_symb))&3];
+
+#ifdef DEBUG_DL_MBSFN
+    printf("subframe %d, l %d, m %d, mprime %d, mprime_dword %d, mprime_qpsk_symbol %d\n",
+           subframe,l,m,mprime, mprime_dword,mprime_qpsk_symb);
+    printf("index = %d (k %d) (%x)\n",(ue->lte_gold_mbsfn_table[subframe][l][mprime_dword]>>(2*mprime_qpsk_symb))&3,k,ue->lte_gold_mbsfn_table[subframe][l][mprime_dword]);
+#endif
+
+    mprime++;
+#ifdef DEBUG_DL_MBSFN
+
+    if (m<18)
+      printf("subframe %d l %d output[%d] = (%d,%d)\n",subframe,l,k,((short *)&output[k])[0],((short *)&output[k])[1]);
+
+#endif
+    k++;
+
+  }
+
+  return(0);
+}
+

openair1/PHY/LTE_REFSIG/lte_gold_mbsfn.c

@@ -94,6 +94,52 @@ void lte_gold_mbsfn(LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_mbsfn_tabl
   }
 }
 
+// note 150 = 24*N_RB_DL_MAX/16 = 24*110/16
+void lte_gold_mbsfn125(LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_mbsfn125_table[10][150],uint16_t Nid_mbsfn)
+{
+
+  unsigned char sfn,l;
+  unsigned int n,x1,x2;//,x1tmp,x2tmp;
+
+  for (sfn=0; sfn<10; sfn++) {
+
+    
+// [IRTGS 16.05.2018]: sfn>>1 removed, "+2" removed as l=0 for 1.25 kHz SCS
+// TS 136.211 ch. 7.2 and ch. 6.10.2.1.2 (1.25 kHz SCS)
+    x2 = (Nid_mbsfn) + (((1+(Nid_mbsfn<<1))*(1 + (7*(1+sfn))))<<9); //cinit
+    //x2 = (Nid_mbsfn) + (((1+(Nid_mbsfn<<1))*(1 + 2 + (7*(1+(sfn>>1)))))<<9); //cinit
+
+
+    x1 = 1+ (1<<31);
+    x2=x2 ^ ((x2 ^ (x2>>1) ^ (x2>>2) ^ (x2>>3))<<31);
+    // skip first 50 double words (1600 bits)
+    //      printf("n=0 : x1 %x, x2 %x\n",x1,x2);
+    
+    for (n=1; n<50; n++) {
+      
+      x1 = (x1>>1) ^ (x1>>4);
+      x1 = x1 ^ (x1<<31) ^ (x1<<28);
+      x2 = (x2>>1) ^ (x2>>2) ^ (x2>>3) ^ (x2>>4);
+      x2 = x2 ^ (x2<<31) ^ (x2<<30) ^ (x2<<29) ^ (x2<<28);
+      //  printf("x1 : %x, x2 : %x\n",x1,x2);
+      
+    }
+
+    for (n=0; n<150; n++) {
+      
+      x1 = (x1>>1) ^ (x1>>4);
+      x1 = x1 ^ (x1<<31) ^ (x1<<28);
+      x2 = (x2>>1) ^ (x2>>2) ^ (x2>>3) ^ (x2>>4);
+      x2 = x2 ^ (x2<<31) ^ (x2<<30) ^ (x2<<29) ^ (x2<<28);
+      lte_gold_mbsfn125_table[sfn][n] = x1^x2;
+      //  printf("n=%d : c %x\n",n,x1^x2);
+    }
+    
+  
+
+  }
+}
+
 
 #ifdef LTE_GOLD_MAIN
 main()

openair1/PHY/LTE_TRANSPORT/dci.c

@@ -341,6 +341,8 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
                   txdataF,
                   subframe);
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_PCFICH,0);
+  if (num_pdcch_symbols==0) return 0;
+
   wbar[0] = &wbar0[0];
   wbar[1] = &wbar1[0];
   y[0] = &yseq0[0];

openair1/PHY/LTE_TRANSPORT/dlsch_coding.c

@@ -718,10 +718,8 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
 
   LTE_DL_FRAME_PARMS *frame_parms = &eNB->frame_parms;
   unsigned char harq_pid = dlsch->harq_ids[frame%2][subframe];
-  if(harq_pid >= dlsch->Mdlharq) {
-    LOG_E(PHY,"dlsch_encoding illegal harq_pid %d\n", harq_pid);
-    return(-1);
-  }
+  AssertFatal(harq_pid< dlsch->Mdlharq,
+	      "dlsch_encoding illegal harq_pid %d\n", harq_pid);
   unsigned short nb_rb = dlsch->harq_processes[harq_pid]->nb_rb;
   unsigned int A;
   unsigned char mod_order;
@@ -758,6 +756,7 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
     */
     // Add 24-bit crc (polynomial A) to payload
 
+    
     crc = crc24a(a,
                  A)>>8;
     a[A>>3] = ((uint8_t*)&crc)[2];

openair1/PHY/LTE_TRANSPORT/pbch.c

@@ -38,7 +38,7 @@
 #include "PHY/sse_intrin.h"
 #include "PHY/LTE_REFSIG/lte_refsig.h"
 
-//#define DEBUG_PBCH 1
+//#define DEBUG_PBCH 1 // [IRTGS 20180709]: commented out
 //#define DEBUG_PBCH_ENCODING
 //#define INTERFERENCE_MITIGATION 1
 

openair1/PHY/LTE_TRANSPORT/pilots_mbsfn.c

@@ -60,7 +60,7 @@ int generate_mbsfn_pilot(PHY_VARS_eNB *eNB,
 
   //antenna 4 symbol 2 Slot 0
   lte_dl_mbsfn(eNB,
-               &txdataF[0][subframe_offset+(2*samples_per_symbol)],
+               &txdataF[4][subframe_offset+(2*samples_per_symbol)],
                amp,
                subframe,
                0);
@@ -69,14 +69,14 @@ int generate_mbsfn_pilot(PHY_VARS_eNB *eNB,
 
   //antenna 4 symbol 0 slot 1
   lte_dl_mbsfn(eNB,
-               &txdataF[0][subframe_offset+(6*samples_per_symbol)],
+               &txdataF[4][subframe_offset+(6*samples_per_symbol)],
                amp,
                subframe,
                1);
 
   //antenna 4 symbol 4 slot 1
   lte_dl_mbsfn(eNB,
-               &txdataF[0][subframe_offset+(10*samples_per_symbol)],
+               &txdataF[4][subframe_offset+(10*samples_per_symbol)],
                amp,
                subframe,
                2);

openair1/PHY/LTE_TRANSPORT/pmch.c

@@ -43,19 +43,21 @@
 
 
 
-void fill_eNB_dlsch_MCH(PHY_VARS_eNB *eNB,int mcs,int ndi,int rvidx)
+
+void fill_eNB_dlsch_MCH(PHY_VARS_eNB *eNB,int Qm,int TBS)
 {
 
+
   LTE_eNB_DLSCH_t *dlsch = eNB->dlsch_MCH;
   LTE_DL_FRAME_PARMS *frame_parms=&eNB->frame_parms;
 
   //  dlsch->rnti   = M_RNTI;
-  dlsch->harq_processes[0]->mcs   = mcs;
-  //  dlsch->harq_processes[0]->Ndi   = ndi;
-  dlsch->harq_processes[0]->rvidx = rvidx;
+
+  dlsch->active=1;
   dlsch->harq_processes[0]->Nl    = 1;
-  dlsch->harq_processes[0]->TBS   = TBStable[get_I_TBS(dlsch->harq_processes[0]->mcs)][frame_parms->N_RB_DL-1];
-  //  dlsch->harq_ids[subframe]       = 0;
+  dlsch->harq_processes[0]->TBS   = TBS;
+  AssertFatal(Qm == 2 || Qm == 4 || Qm == 6, "Illegal value for Qm %d\n",Qm);
+  dlsch->harq_processes[0]->Qm    = Qm;
   dlsch->harq_processes[0]->nb_rb = frame_parms->N_RB_DL;
 
   switch(frame_parms->N_RB_DL) {
@@ -83,26 +85,31 @@ void fill_eNB_dlsch_MCH(PHY_VARS_eNB *eNB,int mcs,int ndi,int rvidx)
 }
 
 
-void generate_mch(PHY_VARS_eNB *eNB,L1_rxtx_proc_t *proc,uint8_t *a)
+
+void generate_mch(PHY_VARS_eNB *eNB,L1_rxtx_proc_t *proc)
 {
 
   int G;
   int subframe = proc->subframe_tx;
   int frame    = proc->frame_tx;
 
+
   G = get_G(&eNB->frame_parms,
 	    eNB->frame_parms.N_RB_DL,
 	    eNB->dlsch_MCH->harq_processes[0]->rb_alloc,
-	    get_Qm(eNB->dlsch_MCH->harq_processes[0]->mcs),1,
+	    eNB->dlsch_MCH->harq_processes[0]->Qm,1,
 	    2,proc->frame_tx,subframe,0);
-  
+
+  LOG_D(PHY,"MCH G %d, Qm %d, rb_alloc[0] %x\n",
+	G,eNB->dlsch_MCH->harq_processes[0]->Qm,eNB->dlsch_MCH->harq_processes[0]->rb_alloc[0]);
+
   generate_mbsfn_pilot(eNB,proc,
 		       eNB->common_vars.txdataF,
 		       AMP);
   
-  
+  eNB->dlsch_MCH->harq_ids[proc->frame_tx&2][subframe]=0;
   AssertFatal(dlsch_encoding(eNB,
-			     a,
+			     eNB->dlsch_MCH->harq_processes[0]->pdu,
 			     1,
 			     eNB->dlsch_MCH,
 			     proc->frame_tx,

openair1/PHY/LTE_TRANSPORT/transport_proto.h

@@ -269,20 +269,16 @@ int mch_modulation(int32_t **txdataF,
 
 /** \brief Top-level generation function for eNB TX of MBSFN
     @param phy_vars_eNB Pointer to eNB variables
-    @param a Pointer to transport block
-    @param abstraction_flag
-
 */
-void generate_mch(PHY_VARS_eNB *phy_vars_eNB,L1_rxtx_proc_t *proc,uint8_t *a);
 
-/** \brief This function generates the frequency-domain pilots (cell-specific downlink reference signals)
+void generate_mch(PHY_VARS_eNB *phy_vars_eNB,L1_rxtx_proc_t *proc);
+
+/** \brief This function fills the DLSCH structure for MCH
     @param phy_vars_eNB Pointer to eNB variables
-    @param proc Pointer to RXn-TXnp4 proc information
-    @param mcs MCS for MBSFN
-    @param ndi new data indicator
-    @param rdvix
+    @param Qm modulation order
+    @param TBS Transport-block size
 */
-void fill_eNB_dlsch_MCH(PHY_VARS_eNB *phy_vars_eNB,int mcs,int ndi,int rvidx);
+void fill_eNB_dlsch_MCH(PHY_VARS_eNB *phy_vars_eNB,int Qm,int TBS);
 
 /** \brief This function generates the frequency-domain pilots (cell-specific downlink reference signals)
     @param phy_vars_ue Pointer to UE variables

openair1/PHY/LTE_UE_TRANSPORT/dlsch_decoding.c

@@ -38,8 +38,7 @@
 #include "common/utils/LOG/vcd_signal_dumper.h"
 #include "PHY/LTE_UE_TRANSPORT/transport_proto_ue.h"
 //#define DEBUG_DLSCH_DECODING
-#define UE_DEBUG_TRACE 1
-
+//#define UE_DEBUG_TRACE 1
 
 void free_ue_dlsch(LTE_UE_DLSCH_t *dlsch)
 {
@@ -359,32 +358,26 @@ decoder_if_t *tc;
 #ifdef DEBUG_DLSCH_DECODING
     printf(" in decoding dlsch->harq_processes[harq_pid]->rvidx = %d\n", dlsch->harq_processes[harq_pid]->rvidx);
 #endif
-    if (lte_rate_matching_turbo_rx(harq_process->RTC[r],
-                                   G,
-                                   harq_process->w[r],
-                                   (uint8_t*)&dummy_w[r][0],
-                                   dlsch_llr+r_offset,
-                                   harq_process->C,
-                                   dlsch->Nsoft,
-                                   dlsch->Mdlharq,
-                                   dlsch->Kmimo,
-                                   harq_process->rvidx,
-                                   (harq_process->round==0)?1:0,
-                                   harq_process->Qm,
-                                   harq_process->Nl,
-                                   r,
-                                   &E)==-1) {
+    AssertFatal(lte_rate_matching_turbo_rx(harq_process->RTC[r],
+					   G,
+					   harq_process->w[r],
+					   (uint8_t*)&dummy_w[r][0],
+					   dlsch_llr+r_offset,
+					   harq_process->C,
+					   dlsch->Nsoft,
+					   dlsch->Mdlharq,
+					   dlsch->Kmimo,
+					   harq_process->rvidx,
+					   (harq_process->round==0)?1:0,
+					   harq_process->Qm,
+					   harq_process->Nl,
+					   r,
+					   &E)!=-1, 
+		"Problem in rate_matching\n");
 #if UE_TIMING_TRACE
-      stop_meas(dlsch_rate_unmatching_stats);
+    stop_meas(dlsch_rate_unmatching_stats);
 #endif
-      LOG_E(PHY,"dlsch_decoding.c: Problem in rate_matching\n");
-      return(dlsch->max_turbo_iterations);
-    } else
-    {
-#if UE_TIMING_TRACE
-      stop_meas(dlsch_rate_unmatching_stats);
-#endif
-    }
+    
     r_offset += E;
 
     /*
@@ -402,39 +395,14 @@ decoder_if_t *tc;
 #if UE_TIMING_TRACE
     stop_meas(dlsch_deinterleaving_stats);
 #endif
-#ifdef DEBUG_DLSCH_DECODING
-    /*
-    if (r==0) {
-              LOG_M("decoder_llr.m","decllr",dlsch_llr,G,1,0);
-              LOG_M("decoder_in.m","dec",&harq_process->d[0][96],(3*8*Kr_bytes)+12,1,0);
-    }
 
-    printf("decoder input(segment %d) :",r);
-    int i; for (i=0;i<(3*8*Kr_bytes)+12;i++)
-      printf("%d : %d\n",i,harq_process->d[r][96+i]);
-      printf("\n");*/
-#endif
-
-
-    //    printf("Clearing c, %p\n",harq_process->c[r]);
     memset(harq_process->c[r],0,Kr_bytes);
 
-    //    printf("done\n");
     if (harq_process->C == 1)
       crc_type = CRC24_A;
     else
       crc_type = CRC24_B;
 
-    /*
-    printf("decoder input(segment %d)\n",r);
-    for (i=0;i<(3*8*Kr_bytes)+12;i++)
-      if ((harq_process->d[r][96+i]>7) ||
-    (harq_process->d[r][96+i] < -8))
-    printf("%d : %d\n",i,harq_process->d[r][96+i]);
-    printf("\n");
-    */
-
-    //#ifndef __AVX2__
 #if 1
     if (err_flag == 0) {
 /*
@@ -442,12 +410,12 @@ decoder_if_t *tc;
                             Kr,r,harq_process->C,harq_process->nb_rb,crc_type,A,harq_process->TBS,
                             harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round,dlsch->max_turbo_iterations);
 */
-    	if (llr8_flag) {
-    		AssertFatal (Kr >= 256, "turbo algo issue Kr=%d cb_cnt=%d C=%d nbRB=%d TBSInput=%d TBSHarq=%d TBSplus24=%d mcs=%d Qm=%d RIV=%d round=%d\n",
-    				Kr,r,harq_process->C,harq_process->nb_rb,A,harq_process->TBS,harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round);
-    	}
+      if (llr8_flag) {
+	AssertFatal (Kr >= 256, "turbo algo issue Kr=%d cb_cnt=%d C=%d nbRB=%d TBSInput=%d TBSHarq=%d TBSplus24=%d mcs=%d Qm=%d RIV=%d round=%d\n",
+		     Kr,r,harq_process->C,harq_process->nb_rb,A,harq_process->TBS,harq_process->B,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round);
+      }
 #if UE_TIMING_TRACE
-        start_meas(dlsch_turbo_decoding_stats);
+      start_meas(dlsch_turbo_decoding_stats);
 #endif
       LOG_D(PHY,"AbsSubframe %d.%d Start turbo segment %d/%d \n",frame%1024,subframe,r,harq_process->C-1);
       ret = tc

openair1/PHY/LTE_UE_TRANSPORT/initial_sync.c

@@ -43,6 +43,7 @@
 
 extern openair0_config_t openair0_cfg[];
 
+
 //#define DEBUG_INITIAL_SYNCH
 
 int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
@@ -52,13 +53,15 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
   LTE_DL_FRAME_PARMS *frame_parms=&ue->frame_parms;
   char phich_resource[6];
 
+
 #ifdef DEBUG_INITIAL_SYNCH
   LOG_I(PHY,"[UE%d] Initial sync: starting PBCH detection (rx_offset %d)\n",ue->Mod_id,
         ue->rx_offset);
 #endif
 
-  for (l=0; l<frame_parms->symbols_per_tti/2; l++) {
 
+  for (l=0; l<frame_parms->symbols_per_tti/2; l++) 
+  {
     slot_fep(ue,
 	     l,
 	     0,
@@ -66,8 +69,10 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
 	     0,
 	     1);
   }
-  for (l=0; l<frame_parms->symbols_per_tti/2; l++) {
 
+
+  for (l=0; l<frame_parms->symbols_per_tti/2; l++) 
+  {
     slot_fep(ue,
 	     l,
 	     1,
@@ -75,6 +80,7 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
 	     0,
 	     1);
   }
+
   slot_fep(ue,
 	   0,
 	   2,
@@ -125,33 +131,54 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
 
   pbch_decoded = 0;
 
-  for (frame_mod4=0; frame_mod4<4; frame_mod4++) {
-    pbch_tx_ant = rx_pbch(&ue->common_vars,
-                          ue->pbch_vars[0],
-                          frame_parms,
-                          0,
-                          SISO,
-                          ue->high_speed_flag,
-                          frame_mod4);
+// [IRTGS 20180613] branch included for non-FeMBMS / dedicated FeMBMS mode
+  for (frame_mod4=0; frame_mod4<4; frame_mod4++) 
+  { if (ue->FeMBMS_active != 2) //non - dedicated FeMBMS mode // prev: == 0
+    {  pbch_tx_ant = rx_pbch(&ue->common_vars,
+                            ue->pbch_vars[0],
+                            frame_parms,
+                            0,
+                            SISO,
+                            ue->high_speed_flag,
+                            frame_mod4);
+    } else // FeMBMS
+    {  pbch_tx_ant = rx_pbch_125(&ue->common_vars,
+                                 ue->pbch_vars[0],
+                                 frame_parms,
+                                 0,
+                                 SISO,
+                                 ue->high_speed_flag,
+                                 frame_mod4);
+    }
 
     if ((pbch_tx_ant>0) && (pbch_tx_ant<=2)) {
       pbch_decoded = 1;
       break;
     }
 
-    pbch_tx_ant = rx_pbch(&ue->common_vars,
-                          ue->pbch_vars[0],
-                          frame_parms,
-                          0,
-                          ALAMOUTI,
-                          ue->high_speed_flag,
-                          frame_mod4);
+    if (ue->FeMBMS_active != 2) //non - dedicated FeMBMS mode
+    { pbch_tx_ant = rx_pbch(&ue->common_vars,
+                            ue->pbch_vars[0],
+                            frame_parms,
+                            0,
+                            ALAMOUTI,
+                            ue->high_speed_flag,
+                            frame_mod4);
+    } else // FeMBMS
+    { pbch_tx_ant = rx_pbch_125(&ue->common_vars,
+                                ue->pbch_vars[0],
+                                frame_parms,
+                                0,
+                                ALAMOUTI,
+                                ue->high_speed_flag,
+                                frame_mod4);
+    }
 
     if ((pbch_tx_ant>0) && (pbch_tx_ant<=2)) {
       pbch_decoded = 1;
       break;
     }
-  }
+}
 
 
   if (pbch_decoded) {
@@ -203,57 +230,83 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
     }
 
 
-    // now check for PHICH parameters
-    frame_parms->phich_config_common.phich_duration = (PHICH_DURATION_t)((ue->pbch_vars[0]->decoded_output[2]>>4)&1);
-    dummy = (ue->pbch_vars[0]->decoded_output[2]>>2)&3;
+// [IRTGS 20180705] for FeMBMS dedicated the content of PBCH is different: TS 136.213 MasterInformationBlock-MBMS
+// There is no PHICH Info, the SFN is only 6 bit long and 2 bits are for AdditionalNonMBSFNSubframes-r14 
+    
+    if (ue->FeMBMS_active != 2) // non-dedicated FeMBMS
+    { // now check for PHICH parameters
+      frame_parms->phich_config_common.phich_duration = (PHICH_DURATION_t)((ue->pbch_vars[0]->decoded_output[2]>>4)&1);
+      dummy = (ue->pbch_vars[0]->decoded_output[2]>>2)&3;
 
-    switch (dummy) {
-    case 0:
-      frame_parms->phich_config_common.phich_resource = oneSixth;
-      sprintf(phich_resource,"1/6");
-      break;
+      switch (dummy) {
+      case 0:
+        frame_parms->phich_config_common.phich_resource = oneSixth;
+        sprintf(phich_resource,"1/6");
+        break;
 
-    case 1:
-      frame_parms->phich_config_common.phich_resource = half;
-      sprintf(phich_resource,"1/2");
-      break;
+      case 1:
+        frame_parms->phich_config_common.phich_resource = half;
+        sprintf(phich_resource,"1/2");
+        break;
 
-    case 2:
-      frame_parms->phich_config_common.phich_resource = one;
-      sprintf(phich_resource,"1");
-      break;
+      case 2:
+        frame_parms->phich_config_common.phich_resource = one;
+        sprintf(phich_resource,"1");
+        break;
 
-    case 3:
-      frame_parms->phich_config_common.phich_resource = two;
-      sprintf(phich_resource,"2");
-      break;
+      case 3:
+        frame_parms->phich_config_common.phich_resource = two;
+        sprintf(phich_resource,"2");
+        break;
 
-    default:
-      LOG_E(PHY,"[UE%d] Initial sync: Unknown PHICH_DURATION\n",ue->Mod_id);
-      return -1;
-      break;
-    }
+      default:
+        LOG_E(PHY,"[UE%d] Initial sync: Unknown PHICH_DURATION\n",ue->Mod_id);
+        return -1;
+        break;
+      }
 
-    for(int i=0; i<RX_NB_TH;i++)
-    {
-        ue->proc.proc_rxtx[i].frame_rx =   (((ue->pbch_vars[0]->decoded_output[2]&3)<<6) + (ue->pbch_vars[0]->decoded_output[1]>>2))<<2;
-        ue->proc.proc_rxtx[i].frame_rx =   (((ue->pbch_vars[0]->decoded_output[2]&3)<<6) + (ue->pbch_vars[0]->decoded_output[1]>>2))<<2;
-
-        ue->proc.proc_rxtx[i].frame_tx = ue->proc.proc_rxtx[0].frame_rx;
-    }
+      for(int i=0; i<RX_NB_TH;i++)
+      {
+          ue->proc.proc_rxtx[i].frame_rx =   (((ue->pbch_vars[0]->decoded_output[2]&3)<<6) + (ue->pbch_vars[0]->decoded_output[1]>>2))<<2;
+          ue->proc.proc_rxtx[i].frame_rx =   (((ue->pbch_vars[0]->decoded_output[2]&3)<<6) + (ue->pbch_vars[0]->decoded_output[1]>>2))<<2;
+ 
+          ue->proc.proc_rxtx[i].frame_tx = ue->proc.proc_rxtx[0].frame_rx;
+      }
 #ifdef DEBUG_INITIAL_SYNCH
-    LOG_I(PHY,"[UE%d] Initial sync: pbch decoded sucessfully p %d, tx_ant %d, frame %d, N_RB_DL %d, phich_duration %d, phich_resource %s!\n",
-          ue->Mod_id,
-          frame_parms->nb_antenna_ports_eNB,
-          pbch_tx_ant,
-          ue->proc.proc_rxtx[0].frame_rx,
-          frame_parms->N_RB_DL,
-          frame_parms->phich_config_common.phich_duration,
-          phich_resource);  //frame_parms->phich_config_common.phich_resource);
+      LOG_I(PHY,"[UE%d] Initial sync: pbch decoded sucessfully p %d, tx_ant %d, frame %d, N_RB_DL %d, phich_duration %d, phich_resource %s!\n",
+            ue->Mod_id,
+            frame_parms->nb_antenna_ports_eNB,
+            pbch_tx_ant,
+            ue->proc.proc_rxtx[0].frame_rx,
+            frame_parms->N_RB_DL,
+            frame_parms->phich_config_common.phich_duration,
+            phich_resource);  //frame_parms->phich_config_common.phich_resource);
 #endif
+    } else // FeMBMS dedicated
+    { for(int i=0; i<RX_NB_TH;i++)
+      {   // Assumption 1: SFN = [do_2(bits[4 3 2 1 0]) do_1(bit 7) 0 0 0 0]   
+          ue->proc.proc_rxtx[i].frame_rx =   (((ue->pbch_vars[0]->decoded_output[2]&31)<<1) + (ue->pbch_vars[0]->decoded_output[1]>>7))<<4;
+          ue->proc.proc_rxtx[i].frame_tx = ue->proc.proc_rxtx[0].frame_rx;
+          // [IRTGS] don't we have to add Frame_mod4 here? -> see ue_pbch_procedures()
+      }
+      // AdditionalNonMBSFNSubframe-r14  2bit
+      frame_parms->AddNonMBSFN_SF = (ue->pbch_vars[0]->decoded_output[1]&96)<<5; // Assumption 1: do[1](bits[6 5])
+
+
+
+#ifdef DEBUG_INITIAL_SYNCH
+      LOG_I(PHY,"[UE%d] Initial sync: FeMBMS pbch decoded sucessfully p %d, tx_ant %d, frame %d, N_RB_DL %d, AdditionalNonMBSFN_SF %d\n",
+            ue->Mod_id,
+            frame_parms->nb_antenna_ports_eNB,
+            pbch_tx_ant,
+            ue->proc.proc_rxtx[0].frame_rx,
+            frame_parms->N_RB_DL,
+            frame_parms->AddNonMBSFN_SF);  
+#endif
+    }
     return(0);
-  } else {
-    return(-1);
+  } else 
+  { return(-1);
   }
 
 }
@@ -264,7 +317,6 @@ char prefix_string[2][9] = {"NORMAL","EXTENDED"};
 
 int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
 {
-
   int32_t sync_pos,sync_pos2,sync_pos_slot;
   int32_t metric_fdd_ncp=0,metric_fdd_ecp=0,metric_tdd_ncp=0,metric_tdd_ecp=0;
   uint8_t phase_fdd_ncp,phase_fdd_ecp,phase_tdd_ncp,phase_tdd_ecp;
@@ -282,6 +334,9 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
   frame_parms->frame_type=FDD;
   frame_parms->nb_antenna_ports_eNB = 2;
 
+  // [IRTGS 20180612]: assume, that system is not in FeMBMS mode (used in pbch_detection)
+  ue->FeMBMS_active = 0;
+
   init_frame_parms(frame_parms,1);
 
   /*
@@ -292,8 +347,14 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
                            frame_parms,
                            (int *)&ue->common_vars.eNb_id);
 
+
   //  LOG_M("rxdata1.m","rxd1",ue->common_vars.rxdata[0],10*frame_parms->samples_per_tti,1,1);
-  if (sync_pos >= frame_parms->nb_prefix_samples)
+
+  if (sync_pos == -1) { 
+    LOG_I(PHY,"\x1B[1;31m%s\x1B[0m\n","[initial_sync]: Sync peak not high enough...");
+    return(-1);
+  } 
+  else if (sync_pos >= frame_parms->nb_prefix_samples)
     sync_pos2 = sync_pos - frame_parms->nb_prefix_samples;
   else
     sync_pos2 = sync_pos + FRAME_LENGTH_COMPLEX_SAMPLES - frame_parms->nb_prefix_samples;
@@ -339,7 +400,6 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
     //write_output("rxdata.m","rxd",ue->common_vars.rxdata[0],10*frame_parms->samples_per_tti,1,1);
   }
 
-
   if (ret==-1) {
 
     // Now FDD extended prefix
@@ -379,12 +439,33 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
       LOG_I(PHY,"FDD Extended prefix: CellId %d metric %d, phase %d, flip %d, pbch %d\n",
             frame_parms->Nid_cell,metric_fdd_ecp,phase_fdd_ecp,flip_fdd_ecp,ret);
 #endif
+
+      // [IRTGS 20180612]
+      // note: FeMBMS is also possible with normal CP, but it is more reasonable to use extended CP.
+      // so, for the moment we only consider FDD extended for FeMBMS dedicated
+      if (ret==-1)
+      { // use FeMBMS_active to branch in pbch_detection between rx_pbch() and rx_pbch_125() 
+        ue->FeMBMS_active = 2; //  try if signal is FeMBMS dedicated
+        ret = pbch_detection(ue,mode);
+      //     write_output("rxdata3.m","rxd3",ue->common_vars.rxdata[0],10*frame_parms->samples_per_tti,1,1);
+ 
+      if (ret==-1) // FeMBMS not successfull
+      { ue->FeMBMS_active = 0; // reset to non FeMBMS mode...
+      }
+
+
+#ifdef DEBUG_INITIAL_SYNCH
+      LOG_I(PHY,"FeMBMS dedicated: FDD Extended prefix: CellId %d metric %d, phase %d, flip %d, pbch %d\n",
+            frame_parms->Nid_cell,metric_fdd_ecp,phase_fdd_ecp,flip_fdd_ecp,ret);
+#endif
+      }
     } else {
 #ifdef DEBUG_INITIAL_SYNCH
       LOG_I(PHY,"FDD Extended prefix: SSS error condition: sync_pos %d, sync_pos_slot %d\n", sync_pos, sync_pos_slot);
 #endif
     }
 
+
     if (ret==-1) {
       // Now TDD normal prefix
       frame_parms->Ncp=NORMAL;
@@ -461,6 +542,7 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
         LOG_I(PHY,"TDD Extended prefix: CellId %d metric %d, phase %d, flip %d, pbch %d\n",
               frame_parms->Nid_cell,metric_tdd_ecp,phase_tdd_ecp,flip_tdd_ecp,ret);
 #endif
+        
       }
     }
   }
@@ -468,7 +550,8 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
   /* Consider this is a false detection if the offset is > 1000 Hz */
   if( (abs(ue->common_vars.freq_offset) > 150) && (ret == 0) )
   {
-	  ret=-1;
+	  //[IRTBL] frequency offset calc maybe wrong. here hard-coded to set it off
+	  //ret=-1;
 #if DISABLE_LOG_X
 	  printf("Ignore MIB with high freq offset [%d Hz] estimation \n",ue->common_vars.freq_offset);
 #else
@@ -476,6 +559,7 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode)
 #endif
   }
 
+
   if (ret==0) {  // PBCH found so indicate sync to higher layers and configure frame parameters
 
     //#ifdef DEBUG_INITIAL_SYNCH

openair1/PHY/LTE_UE_TRANSPORT/pbch_ue.c

@@ -401,6 +401,40 @@ void pbch_unscrambling(LTE_DL_FRAME_PARMS *frame_parms,
   }
 }
 
+// [IRTGS 20180612] ******************************
+// Note _125 here does NOT mean that it is used for 1.25 kHz SCS, instead for 
+// FeMBMS dedicated we do have another c_init, therefore another unscrambling... 
+void pbch_unscrambling_125(LTE_DL_FRAME_PARMS *frame_parms,
+                       int8_t* llr,
+                       uint32_t length,
+                       uint8_t frame_mod4)
+{
+  int i;
+  uint8_t reset;
+  uint32_t x1, x2, s=0;
+
+  reset = 1;
+  // x1 is set in first call to lte_gold_generic
+  x2 = frame_parms->Nid_cell+(1<<9); //this is c_init for FeMBMS in 36.211 Sec 6.6.1
+  //  msg("pbch_unscrambling: Nid_cell = %d\n",x2);
+
+  for (i=0; i<length; i++) {
+    if (i%32==0) {
+      s = lte_gold_generic(&x1, &x2, reset);
+      //      printf("lte_gold[%d]=%x\n",i,s);
+      reset = 0;
+    }
+
+// [IRTGS]: not sure whether modifications are required here -> check! *****************
+    // take the quarter of the PBCH that corresponds to this frame
+    if ((i>=(frame_mod4*(length>>2))) && (i<((1+frame_mod4)*(length>>2)))) {
+
+      if (((s>>(i%32))&1)==0)
+        llr[i] = -llr[i];
+    }
+  }
+}
+
 void pbch_alamouti(LTE_DL_FRAME_PARMS *frame_parms,
                    int **rxdataF_comp,
                    uint8_t symbol)
@@ -630,3 +664,183 @@ uint16_t rx_pbch(LTE_UE_COMMON *lte_ue_common_vars,
 
 
 }
+
+// [IRTGS 20180612] 
+// Just a copy of rx_pbch() the only difference: call of pbch_unscrambling_125()
+// Unfortunatelly FeMBMS_active is one element of PHY_VARS_UE structure and 
+// rx_pbch() only gets LTE_UE_COMMON (sub-) structure
+// for the moment, we found it easier just to add rx_pbch125()
+
+uint16_t rx_pbch_125(LTE_UE_COMMON *lte_ue_common_vars,
+                 LTE_UE_PBCH *lte_ue_pbch_vars,
+                 LTE_DL_FRAME_PARMS *frame_parms,
+                 uint8_t eNB_id,
+                 MIMO_mode_t mimo_mode,
+                 uint32_t high_speed_flag,
+                 uint8_t frame_mod4)
+{
+
+  uint8_t log2_maxh;//,aatx,aarx;
+  int max_h=0;
+
+  int symbol,i;
+  uint32_t nsymb = (frame_parms->Ncp==0) ? 14:12;
+  uint16_t  pbch_E;
+  uint8_t pbch_a[8];
+  uint8_t RCC;
+
+  int8_t *pbch_e_rx;
+  uint8_t *decoded_output = lte_ue_pbch_vars->decoded_output;
+  uint16_t crc;
+
+
+  //  pbch_D    = 16+PBCH_A;
+
+  pbch_E  = (frame_parms->Ncp==0) ? 1920 : 1728; //RE/RB * #RB * bits/RB (QPSK)
+  pbch_e_rx = &lte_ue_pbch_vars->llr[frame_mod4*(pbch_E>>2)];
+#ifdef DEBUG_PBCH
+  LOG_D(PHY,"[PBCH] starting symbol loop (Ncp %d, frame_mod4 %d,mimo_mode %d\n",frame_parms->Ncp,frame_mod4,mimo_mode);
+#endif
+
+  // clear LLR buffer
+  memset(lte_ue_pbch_vars->llr,0,pbch_E);
+
+  for (symbol=(nsymb>>1); symbol<(nsymb>>1)+4; symbol++) {
+
+#ifdef DEBUG_PBCH
+    LOG_D(PHY,"[PBCH] starting extract\n");
+#endif
+    pbch_extract(lte_ue_common_vars->common_vars_rx_data_per_thread[0].rxdataF,
+                 lte_ue_common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates[eNB_id],
+                 lte_ue_pbch_vars->rxdataF_ext,
+                 lte_ue_pbch_vars->dl_ch_estimates_ext,
+                 symbol,
+                 high_speed_flag,
+                 frame_parms);
+#ifdef DEBUG_PBCH
+    LOG_D(PHY,"[PHY] PBCH Symbol %d\n",symbol);
+    LOG_D(PHY,"[PHY] PBCH starting channel_level\n");
+#endif
+
+    max_h = pbch_channel_level(lte_ue_pbch_vars->dl_ch_estimates_ext,
+                               frame_parms,
+                               symbol);
+    log2_maxh = 3+(log2_approx(max_h)/2);
+
+#ifdef DEBUG_PBCH
+    LOG_D(PHY,"[PHY] PBCH log2_maxh = %d (%d)\n",log2_maxh,max_h);
+#endif
+
+    pbch_channel_compensation(lte_ue_pbch_vars->rxdataF_ext,
+                              lte_ue_pbch_vars->dl_ch_estimates_ext,
+                              lte_ue_pbch_vars->rxdataF_comp,
+                              frame_parms,
+                              symbol,
+                              log2_maxh); // log2_maxh+I0_shift
+
+    if (frame_parms->nb_antennas_rx > 1)
+      pbch_detection_mrc(frame_parms,
+                         lte_ue_pbch_vars->rxdataF_comp,
+                         symbol);
+
+
+    if (mimo_mode == ALAMOUTI) {
+      pbch_alamouti(frame_parms,lte_ue_pbch_vars->rxdataF_comp,symbol);
+    } else if (mimo_mode != SISO) {
+      LOG_D(PHY,"[PBCH][RX] Unsupported MIMO mode\n");
+      return(-1);
+    }
+
+    if (symbol>(nsymb>>1)+1) {
+      pbch_quantize(pbch_e_rx,
+                    (short*)&(lte_ue_pbch_vars->rxdataF_comp[0][(symbol%(nsymb>>1))*72]),
+                    144);
+
+      pbch_e_rx+=144;
+    } else {
+      pbch_quantize(pbch_e_rx,
+                    (short*)&(lte_ue_pbch_vars->rxdataF_comp[0][(symbol%(nsymb>>1))*72]),
+                    96);
+
+      pbch_e_rx+=96;
+    }
+
+
+  }
+
+  pbch_e_rx = lte_ue_pbch_vars->llr;
+
+
+
+  //un-scrambling
+#ifdef DEBUG_PBCH
+  LOG_D(PHY,"[PBCH] doing unscrambling\n");
+#endif
+
+
+  pbch_unscrambling_125(frame_parms,
+                    pbch_e_rx,
+                    pbch_E,
+                    frame_mod4);
+
+
+
+  //un-rate matching
+#ifdef DEBUG_PBCH
+  LOG_D(PHY,"[PBCH] doing un-rate-matching\n");
+#endif
+
+
+  memset(dummy_w_rx,0,3*3*(16+PBCH_A));
+  RCC = generate_dummy_w_cc(16+PBCH_A,
+                            dummy_w_rx);
+
+
+  lte_rate_matching_cc_rx(RCC,pbch_E,pbch_w_rx,dummy_w_rx,pbch_e_rx);
+
+  sub_block_deinterleaving_cc((unsigned int)(PBCH_A+16),
+                              &pbch_d_rx[96],
+                              &pbch_w_rx[0]);
+
+  memset(pbch_a,0,((16+PBCH_A)>>3));
+
+
+
+
+  phy_viterbi_lte_sse2(pbch_d_rx+96,pbch_a,16+PBCH_A);
+
+  // Fix byte endian of PBCH (bit 23 goes in first)
+  for (i=0; i<(PBCH_A>>3); i++)
+    decoded_output[(PBCH_A>>3)-i-1] = pbch_a[i];
+
+#ifdef DEBUG_PBCH
+
+  for (i=0; i<(PBCH_A>>3); i++)
+    LOG_I(PHY,"[PBCH] pbch_a[%d] = %x\n",i,decoded_output[i]);
+
+#endif //DEBUG_PBCH
+
+#ifdef DEBUG_PBCH
+  LOG_I(PHY,"PBCH CRC %x : %x\n",
+      crc16(pbch_a,PBCH_A),
+      ((uint16_t)pbch_a[PBCH_A>>3]<<8)+pbch_a[(PBCH_A>>3)+1]);
+#endif
+
+  crc = (crc16(pbch_a,PBCH_A)>>16) ^
+        (((uint16_t)pbch_a[PBCH_A>>3]<<8)+pbch_a[(PBCH_A>>3)+1]);
+
+  // [IRTGS 20180620]
+  // printf("\x1B[1;34m[IRTGS]: \x1B[0m"); // blue
+  // printf("\x1B[32m%s%d%s%X\x1B[0m\n","frame_mod4 = ", frame_mod4, ";   CRC = ",crc);
+
+  if (crc == 0x0000)
+    return(1);
+  else if (crc == 0xffff)
+    return(2);
+  else if (crc == 0x5555)
+    return(4);
+  else
+    return(-1);
+
+
+}

openair1/PHY/LTE_UE_TRANSPORT/pmch_ue.c

@@ -100,7 +100,7 @@ void fill_UE_dlsch_MCH(PHY_VARS_UE *ue,int mcs,int ndi,int rvidx,int eNB_id)
   dlsch->harq_processes[0]->TBS = TBStable[get_I_TBS(dlsch->harq_processes[0]->mcs)][frame_parms->N_RB_DL-1];
   dlsch->current_harq_pid = 0;
   dlsch->harq_processes[0]->nb_rb = frame_parms->N_RB_DL;
-
+  dlsch->harq_processes[0]->Qm    = get_Qm(mcs);
   switch(frame_parms->N_RB_DL) {
   case 6:
     dlsch->harq_processes[0]->rb_alloc_even[0] = 0x3f;
@@ -189,11 +189,73 @@ void mch_extract_rbs(int **rxdataF,
 
 }
 
+void mch_extract_rbs125(int **rxdataF,
+			int **dl_ch_estimates,
+			int **rxdataF_ext,
+			int **dl_ch_estimates_ext,
+			unsigned char subframe,
+			LTE_DL_FRAME_PARMS *frame_parms)
+{
+
+  int i,j,offset,aarx;
+  int first_carrier_offset;
+
+  offset = 3*(subframe&1);
+
+// [IRTGS 20180717] values for 1.4 MHz and 3 MHz semm to be not correct
+// see PHY/INIT(lte_parms.c -> init_frame_parms(): 90x12 = 1080; 36x12 = 432
+
+
+  switch (frame_parms->N_RB_DL) {
+  case 6:
+    //first_carrier_offset=1536-450;
+    first_carrier_offset=1536-432;
+    break;
+  case 15:
+    //first_carrier_offset=3072-900;
+    first_carrier_offset=3072-1080;
+    break;
+  case 25:
+    first_carrier_offset=6144-1800;
+    break;
+  case 50:
+    first_carrier_offset=12288-3600;
+    break;
+  case 75:
+    first_carrier_offset=18432-5400;
+    break;
+  case 100:
+    first_carrier_offset=24576-7200;
+    break;
+  default:
+    AssertFatal(1==0,"Illegal N_RB_DL %d\n",frame_parms->N_RB_DL);
+    break;
+  }
+  for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+
+    for (i=offset,j=0; i<frame_parms->N_RB_DL*72; i+=6,j++) {
+      /*  printf("MCH with pilots: i %d, j %d => %d,%d\n",i,j,
+       *(int16_t*)&rxdataF[aarx][i+frame_parms->first_carrier_offset + (symbol*frame_parms->ofdm_symbol_size)],
+       *(int16_t*)(1+&rxdataF[aarx][i+frame_parms->first_carrier_offset + (symbol*frame_parms->ofdm_symbol_size)]));
+       */
+      // negative half of RX frequency vector
+      rxdataF_ext[aarx][j]                                     = rxdataF[aarx][i+first_carrier_offset];
+      // positive half of RX frequency vector
+      rxdataF_ext[aarx][(frame_parms->N_RB_DL*2*12)+j]         = rxdataF[aarx][i+1];
+      // negative half of channel response frequency vector
+      dl_ch_estimates_ext[aarx][j]                             = dl_ch_estimates[aarx][i];
+      // positive half of channel response frequency vector
+      dl_ch_estimates_ext[aarx][(frame_parms->N_RB_DL*2*12)+j] = dl_ch_estimates[aarx][i+(frame_parms->N_RB_DL*72)];
+    }
+  }
+}
+
 void mch_channel_level(int **dl_ch_estimates_ext,
                        LTE_DL_FRAME_PARMS *frame_parms,
                        int *avg,
                        uint8_t symbol,
-                       unsigned short nb_rb)
+		       int FeMBMS_flag)
 {
 
   int i,aarx,nre;
@@ -213,10 +275,15 @@ void mch_channel_level(int **dl_ch_estimates_ext,
 
 
 #endif
-    if ((symbol == 2) || (symbol == 6) || (symbol == 10))
-      nre = (frame_parms->N_RB_DL*6);
-    else
-      nre = (frame_parms->N_RB_DL*12);
+    if (FeMBMS_flag == 0) {
+      if ((symbol == 2) || (symbol == 6) || (symbol == 10))
+	nre = (frame_parms->N_RB_DL*6);
+      else
+	nre = (frame_parms->N_RB_DL*12);
+    } 
+    else if (FeMBMS_flag == 2) nre = frame_parms->N_RB_DL*120;
+    else AssertFatal(1==0,"Illegal FeMBMS_flag %d\n",FeMBMS_flag);
+ 
 
     for (i=0; i<(nre>>2); i++) {
 #if defined(__x86_64__) || defined(__i386__)
@@ -248,7 +315,8 @@ void mch_channel_compensation(int **rxdataF_ext,
                               LTE_DL_FRAME_PARMS *frame_parms,
                               unsigned char symbol,
                               unsigned char mod_order,
-                              unsigned char output_shift)
+                              unsigned char output_shift,
+			      int FeMBMS_flag)
 {
 
   int aarx,nre,i;
@@ -258,10 +326,18 @@ void mch_channel_compensation(int **rxdataF_ext,
 #elif defined(__arm__)
 
 #endif
-  if ((symbol == 2) || (symbol == 6) || (symbol == 10))
-    nre = frame_parms->N_RB_DL*6;
-  else
-    nre = frame_parms->N_RB_DL*12;
+  if (FeMBMS_flag == 0) {
+    if ((symbol == 2) || (symbol == 6) || (symbol == 10))
+      nre = frame_parms->N_RB_DL*6;
+    else
+      nre = frame_parms->N_RB_DL*12;
+  }
+  else if (FeMBMS_flag == 1) { // 7.5 kHz SCS
+    AssertFatal(1==0,"7.5 kHz SCS not supported yet\n");
+  }
+  else { // 1.25kHz SCS
+    nre = frame_parms->N_RB_DL*120;
+  }
 
 #if defined(__x86_64__) || defined(__i386__)
   if (mod_order == 4) {
@@ -393,7 +469,8 @@ void mch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
                        int **rxdataF_comp,
                        int **dl_ch_mag,
                        int **dl_ch_magb,
-                       unsigned char symbol)
+                       unsigned char symbol,
+		       int FeMBMS_flag)
 {
 
 
@@ -403,6 +480,12 @@ void mch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
 #elif defined(__arm__)
   int16x8_t *rxdataF_comp128_0,*rxdataF_comp128_1,*dl_ch_mag128_0,*dl_ch_mag128_1,*dl_ch_mag128_0b,*dl_ch_mag128_1b;
 #endif
+  int length;
+
+  if (FeMBMS_flag == 0) length = 3*frame_parms->N_RB_DL;
+  else if (FeMBMS_flag == 2) length = 36*frame_parms->N_RB_DL;
+  else AssertFatal(1==0,"unsupported FeMBMS_flag %d\n",FeMBMS_flag);
+
   if (frame_parms->nb_antennas_rx>1) {
 
 #if defined(__x86_64__) || defined(__i386__)
@@ -424,7 +507,7 @@ void mch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
 
 #endif
     // MRC on each re of rb, both on MF output and magnitude (for 16QAM/64QAM llr computation)
-    for (i=0; i<frame_parms->N_RB_DL*3; i++) {
+    for (i=0; i<length; i++) {
 #if defined(__x86_64__) || defined(__i386__)
       rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
       dl_ch_mag128_0[i]    = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0[i],1),_mm_srai_epi16(dl_ch_mag128_1[i],1));
@@ -446,27 +529,36 @@ int mch_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
                  int **rxdataF_comp,
                  short *dlsch_llr,
                  unsigned char symbol,
-                 short **llr32p)
+                 short **llr32p,
+		 int FeMBMS_flag)
 {
 
   uint32_t *rxF = (uint32_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
   uint32_t *llr32;
   int i,len;
 
-  if (symbol==2) {
-    llr32 = (uint32_t*)dlsch_llr;
-  } else {
-    llr32 = (uint32_t*)(*llr32p);
+  if (FeMBMS_flag == 0) {
+    if (symbol==2) {
+      llr32 = (uint32_t*)dlsch_llr;
+    } else {
+      llr32 = (uint32_t*)(*llr32p);
+    }
   }
+  else if (FeMBMS_flag == 2) llr32 = (uint32_t*)dlsch_llr;
+  else AssertFatal(1==0,"Illegal FeMBMS_flag %d\n",FeMBMS_flag);
 
   AssertFatal(llr32!=NULL,"dlsch_qpsk_llr: llr is null, symbol %d, llr32=%p\n",symbol, llr32);
 
-
-  if ((symbol==2) || (symbol==6) || (symbol==10)) {
-    len = frame_parms->N_RB_DL*6;
-  } else {
-    len = frame_parms->N_RB_DL*12;
+  if (FeMBMS_flag == 0) {
+    if ((symbol==2) || (symbol==6) || (symbol==10)) {
+      len = frame_parms->N_RB_DL*6;
+    } else {
+      len = frame_parms->N_RB_DL*12;
+    }
   }
+  else if (FeMBMS_flag == 2) len = frame_parms->N_RB_DL*120;
+  else AssertFatal(1==0,"Illegal FeMBMS_flag %d\n",FeMBMS_flag);  
+
 
   //  printf("dlsch_qpsk_llr: symbol %d,len %d,pbch_pss_sss_adjust %d\n",symbol,len,pbch_pss_sss_adjust);
   for (i=0; i<len; i++) {
@@ -494,7 +586,8 @@ void mch_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                    short *dlsch_llr,
                    int **dl_ch_mag,
                    unsigned char symbol,
-                   int16_t **llr32p)
+                   int16_t **llr32p,
+		   int FeMBMS_flag)
 {
 
 #if defined(__x86_64__) || defined(__i386__)
@@ -529,12 +622,15 @@ void mch_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
 #elif defined(__arm__)
   ch_mag = (int16x8_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
 #endif
-  if ((symbol==2) || (symbol==6) || (symbol==10)) {
-    len = frame_parms->N_RB_DL*6;
-  } else {
-    len = frame_parms->N_RB_DL*12;
+  if (FeMBMS_flag ==0) {
+    if ((symbol==2) || (symbol==6) || (symbol==10)) {
+      len = frame_parms->N_RB_DL*6;
+    } else {
+      len = frame_parms->N_RB_DL*12;
+    }
   }
-
+  else if (FeMBMS_flag ==2 ) len = frame_parms->N_RB_DL*120;
+  else AssertFatal(1==0,"Illegal FeMBMS_flag %d\n",FeMBMS_flag);
 
 
   // update output pointer according to number of REs in this symbol (<<2 because 4 bits per RE)
@@ -609,7 +705,8 @@ void mch_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                    int **dl_ch_mag,
                    int **dl_ch_magb,
                    unsigned char symbol,
-                   short **llr_save)
+                   short **llr_save,
+		   int FeMBMS_flag)
 {
 
 #if defined(__x86_64__) || defined(__i386__)
@@ -638,12 +735,15 @@ void mch_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
   ch_mag = (int16x8_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
   ch_magb = (int16x8_t*)&dl_ch_magb[0][(symbol*frame_parms->N_RB_DL*12)];
 #endif
-  if ((symbol==2) || (symbol==6) || (symbol==10)) {
-    len = frame_parms->N_RB_DL*6;
-  } else {
-    len = frame_parms->N_RB_DL*12;
+  if (FeMBMS_flag ==0) {
+    if ((symbol==2) || (symbol==6) || (symbol==10)) {
+      len = frame_parms->N_RB_DL*6;
+    } else {
+      len = frame_parms->N_RB_DL*12;
+    }
   }
-
+  else if (FeMBMS_flag ==2 ) len = frame_parms->N_RB_DL*120;
+  else AssertFatal(1==0,"Illegal FeMBMS_flag %d\n",FeMBMS_flag);
 
   llr2 = llr;
   llr += (len*6);
@@ -749,7 +849,8 @@ void mch_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
 #endif
 }
 
-int avg_pmch[4];
+
+
 int rx_pmch(PHY_VARS_UE *ue,
             unsigned char eNB_id,
             uint8_t subframe,
@@ -761,23 +862,36 @@ int rx_pmch(PHY_VARS_UE *ue,
   LTE_DL_FRAME_PARMS *frame_parms    = &ue->frame_parms;
   LTE_UE_DLSCH_t   **dlsch        = &ue->dlsch_MCH[eNB_id];
   int avgs,aarx;
+  int avg_pmch[4];
 
   //printf("*********************mch: symbol %d\n",symbol);
 
-  mch_extract_rbs(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
-                  common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id],
-                  pdsch_vars[eNB_id]->rxdataF_ext,
-                  pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-                  symbol,
-                  subframe,
-                  frame_parms);
+  if (ue->FeMBMS_active == 0) 
+    mch_extract_rbs(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+		    common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id],
+		    pdsch_vars[eNB_id]->rxdataF_ext,
+		    pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+		    symbol,
+		    subframe,
+		    frame_parms);
+  else if (ue->FeMBMS_active == 2)  // FeMBMS dedicated
+    mch_extract_rbs125(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+		       common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id],
+		       pdsch_vars[eNB_id]->rxdataF_ext,
+		       pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+		       subframe,
+		       frame_parms);
+
+  else AssertFatal(1==0,"Illegal FeMBMS_active %d\n",ue->FeMBMS_active);
+
 
   if (symbol == 2) {
     mch_channel_level(pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                       frame_parms,
                       avg_pmch,
                       symbol,
-                      frame_parms->N_RB_DL);
+                      ue->FeMBMS_active == 0 ? 0 : 2
+		      );
   }
 
   avgs = 0;
@@ -798,7 +912,8 @@ int rx_pmch(PHY_VARS_UE *ue,
                            frame_parms,
                            symbol,
                            get_Qm(dlsch[0]->harq_processes[0]->mcs),
-                           pdsch_vars[eNB_id]->log2_maxh);
+                           pdsch_vars[eNB_id]->log2_maxh,
+			   ue->FeMBMS_active == 0 ? 0 : 2);
 
 
   if (frame_parms->nb_antennas_rx > 1)
@@ -806,7 +921,8 @@ int rx_pmch(PHY_VARS_UE *ue,
                       pdsch_vars[eNB_id]->rxdataF_comp0,
                       pdsch_vars[eNB_id]->dl_ch_mag0,
                       pdsch_vars[eNB_id]->dl_ch_magb0,
-                      symbol);
+                      symbol,
+		      ue->FeMBMS_active == 0 ? 0 : 2);
 
   switch (get_Qm(dlsch[0]->harq_processes[0]->mcs)) {
   case 2 :
@@ -814,7 +930,8 @@ int rx_pmch(PHY_VARS_UE *ue,
                  pdsch_vars[eNB_id]->rxdataF_comp0,
                  pdsch_vars[eNB_id]->llr[0],
                  symbol,
-                 pdsch_vars[eNB_id]->llr128);
+                 pdsch_vars[eNB_id]->llr128,
+		 ue->FeMBMS_active == 0 ? 0 : 2);
     break;
 
   case 4:
@@ -823,7 +940,8 @@ int rx_pmch(PHY_VARS_UE *ue,
                   pdsch_vars[eNB_id]->llr[0],
                   pdsch_vars[eNB_id]->dl_ch_mag0,
                   symbol,
-                  pdsch_vars[eNB_id]->llr128);
+                  pdsch_vars[eNB_id]->llr128,
+		  ue->FeMBMS_active == 0 ? 0 : 2);
     break;
 
   case 6:
@@ -833,7 +951,8 @@ int rx_pmch(PHY_VARS_UE *ue,
                   pdsch_vars[eNB_id]->dl_ch_mag0,
                   pdsch_vars[eNB_id]->dl_ch_magb0,
                   symbol,
-                  pdsch_vars[eNB_id]->llr128);
+                  pdsch_vars[eNB_id]->llr128,
+		  ue->FeMBMS_active == 0 ? 0 : 2);
     break;
   }
 

openair1/PHY/LTE_UE_TRANSPORT/transport_proto_ue.h

@@ -1124,7 +1124,14 @@ uint16_t rx_pbch(LTE_UE_COMMON *lte_ue_common_vars,
                  MIMO_mode_t mimo_mode,
                  uint32_t high_speed_flag,
                  uint8_t frame_mod4);
-
+// [IRTGS 20180613] same for FeMBMS
+uint16_t rx_pbch_125(LTE_UE_COMMON *lte_ue_common_vars,
+                 LTE_UE_PBCH *lte_ue_pbch_vars,
+                 LTE_DL_FRAME_PARMS *frame_parms,
+                 uint8_t eNB_id,
+                 MIMO_mode_t mimo_mode,
+                 uint32_t high_speed_flag,
+                 uint8_t frame_mod4);
 uint16_t rx_pbch_emul(PHY_VARS_UE *phy_vars_ue,
                       uint8_t eNB_id,
                       uint8_t pbch_phase);
@@ -1140,6 +1147,11 @@ void pbch_unscrambling(LTE_DL_FRAME_PARMS *frame_parms,
                        int8_t* llr,
                        uint32_t length,
                        uint8_t frame_mod4);
+// [IRTGS 20180613] same for FeMBMS (uses different cinit)
+void pbch_unscrambling_125(LTE_DL_FRAME_PARMS *frame_parms,
+                       int8_t* llr,
+                       uint32_t length,
+                       uint8_t frame_mod4);
 
 /*! \brief Top-level generation route for Sidelink BCH,PSS and SSS
   \param ue pointer to UE descriptor

openair1/PHY/MODULATION/beamforming.c

@@ -62,6 +62,7 @@ int beam_precoding(int32_t **txdataF,
 		   int p,
                    int l1_id)
 {
+
   int rb_offset_neg0 = frame_parms->ofdm_symbol_size - (6*frame_parms->N_RB_DL);
   int rb_offset_neg  = (subframe*frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti) + rb_offset_neg0;
   int rb_offset_pos  = (subframe*frame_parms->ofdm_symbol_size*frame_parms->symbols_per_tti);
@@ -80,7 +81,7 @@ int beam_precoding(int32_t **txdataF,
                      7*frame_parms->N_RB_DL, // to allow for extra RE at the end, 12 useless multipy-adds (first one at DC and 11 at end)
                      15);
 
-      return 0;
+  return 0;
 }
 
 

openair1/PHY/MODULATION/slot_fep_mbsfn.c

@@ -93,6 +93,7 @@ int slot_fep_mbsfn(PHY_VARS_UE *ue,
     return(-1);
   }
 
+
   if (((subframe == 0) || (subframe == 5) ||    // SFn 0,4,5,9;
        (subframe == 4) || (subframe == 9))
       && (frame_type==FDD) )    {   //check for valid MBSFN subframe
@@ -204,3 +205,166 @@ int slot_fep_mbsfn(PHY_VARS_UE *ue,
 #endif
   return(0);
 }
+
+
+
+
+int slot_fep_mbsfn125(PHY_VARS_UE *ue,
+		      int subframe,
+		      int sample_offset)
+{
+ 
+	printf("\x1B[32m");
+        printf("[IRTBL] Entering slot_fep_mbsfn125\n");
+        printf("\x1B[0m");
+
+
+
+  LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
+  LTE_UE_COMMON *common_vars   = &ue->common_vars;
+  uint8_t eNB_id = 0;//ue_common_vars->eNb_id;
+
+  unsigned char aa;
+  unsigned char frame_type = frame_parms->frame_type; // Frame Type: 0 - FDD, 1 - TDD;
+  unsigned int nb_prefix_samples;
+  int ofdm_symbol_size;
+  unsigned int subframe_offset;
+
+  //   int i;
+  unsigned int frame_length_samples = frame_parms->samples_per_tti * 10;
+//unsigned int frame_length_samples = frame_parms->samples_per_tti * 10 * 4; //40 ms frame? IRTBL
+  
+void (*dft)(int16_t *,int16_t *, int);
+
+//IRTBL
+//ue->FeMBMS_active = 1;
+//frame_parms->frame_type = FDD;
+//END
+  AssertFatal(ue->FeMBMS_active ==2, "This is not an FeMBMS UE!\n"); //changed from 1 to 2 IRTBL
+  AssertFatal(frame_parms->frame_type == FDD, "Frame is TDD!\n");
+  
+  switch (frame_parms->ofdm_symbol_size) {
+    
+  case 128:
+    dft = dft1536;
+    ofdm_symbol_size=1536;
+    nb_prefix_samples=384;
+    break;
+  case 256:
+    AssertFatal(1==0,"FeMBMS dft3072 not implemented\n");
+    dft = dft3072;
+    ofdm_symbol_size=3072;
+    nb_prefix_samples=768;
+    break;
+    
+  case 512:
+    dft = dft6144;
+    nb_prefix_samples=1536;
+    ofdm_symbol_size=6144;
+    break;
+    
+  case 1024:
+    dft = dft12288;
+    nb_prefix_samples=3072;
+    ofdm_symbol_size=12288;
+    break;
+    
+  case 1536:
+    dft = dft18432;
+    nb_prefix_samples=4608;
+    ofdm_symbol_size=18432;
+    break;
+    
+  case 2048:
+    dft = dft24576;
+    nb_prefix_samples=6144;
+    ofdm_symbol_size=24576;
+    break;
+    
+  default:
+    AssertFatal(1==0,"Illegal ofdm symbol size %d\n",frame_parms->ofdm_symbol_size);
+    break;
+  }
+  
+
+        printf("\x1B[32m");
+        //printf("[IRTBL] selected LTE OFDM Symbol Size: %i\n",frame_parms->ofdm_symbol_size); 
+	//printf("[IRTBL] selected FeMBMS DFT Size: %i\n",dft6144); //more complex, not only a single value
+	//printf("[IRTBL] selected NB Prefix Samples: %i\n",nb_prefix_samples);
+	//printf("[IRTBL] selected FeMBMS OFDM Symbol Size: %i\n",ofdm_symbol_size);
+        printf("\x1B[0m");
+
+
+  subframe_offset = frame_parms->samples_per_tti * subframe;
+  
+        printf("\x1B[32m");
+        printf("[IRTBL] Subframe: %i\n",subframe);
+        //printf("[IRTBL] Subframe * 10: %i\n",subframe*10);
+	//printf("[IRTBL] Subframe * 10 bit-und 3: %i\n",(subframe*10)&3);
+	//printf("[IRTBL] Subframe * 10 modulo 4: %i\n",(subframe*10)%4);
+	printf("\x1B[0m");
+
+   //AssertFatal((subframe > 0) || ((frame&3) > 0), "This is a regular LTE subframe in FeMBMS\n");
+   //AssertFatal((subframe > 0) || (((subframe*10)&3) > 0), "This is a regular LTE subframe in FeMBMS\n");
+  
+  
+#ifdef DEBUG_FEP
+  LOG_D(PHY,"slot_fep_mbsfn125: subframe %d, nb_prefix_samples %d, subframe_offset %d, sample_offset %d\n", subframe, nb_prefix_samples,subframe_offset,
+	sample_offset);
+#endif
+  
+  for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
+    memset(&common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aa][0],0,ofdm_symbol_size*sizeof(int));
+#if UE_TIMING_TRACE
+    start_meas(&ue->rx_dft_stats);
+#endif
+    dft((int16_t *)&common_vars->rxdata[aa][(sample_offset +
+					     nb_prefix_samples +
+					     subframe_offset -
+					     SOFFSET) % frame_length_samples],
+	(int16_t *)&common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aa][0],1);
+#if UE_TIMING_TRACE
+    stop_meas(&ue->rx_dft_stats);
+#endif
+  }
+  
+
+
+  for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
+    if (ue->perfect_ce == 0) {
+#ifdef DEBUG_FEP
+      LOG_D(PHY,"Channel estimation eNB %d, aatx %d, subframe %d\n",eNB_id,aa,subframe);
+#endif
+      /*
+	lte_dl_mbsfn125_channel_estimation(ue,
+	eNB_id,
+	0,
+	subframe);
+      */
+      
+      // do frequency offset estimation here!
+      
+#ifdef DEBUG_FEP
+      LOG_D(PHY,"Frequency offset estimation\n");
+#endif
+      
+      /*    New function to be created to do frequency offset estimation for 1.25 kHz SCS numerology
+	    lte_mbsfn125_est_freq_offset(common_vars->dl_ch_estimates[0],
+	    frame_parms,
+	    l,
+	    &common_vars->freq_offset); */
+    }
+    }
+      
+      
+#ifdef DEBUG_FEP
+  LOG_D(PHY,"slot_fep_mbsfn: done\n");
+#endif
+
+        printf("\x1B[32m");
+        printf("[IRTBL] Leaving slot_fep_mbsfn125\n");
+        printf("\x1B[0m");
+
+
+  return(0);
+    }

openair1/PHY/TOOLS/lte_dfts.c

@@ -5567,6 +5567,7 @@ void idft3072(int16_t *input, int16_t *output,int scale)
 }
 
 
+
 int16_t twa6144[4096] __attribute__((aligned(32)));
 int16_t twb6144[4096] __attribute__((aligned(32)));
 
@@ -5891,6 +5892,7 @@ void idft18432(int16_t *input, int16_t *output,int scale) {
 	   (simd_q15_t*)(output+i),(simd_q15_t*)(output+12288+i),(simd_q15_t*)(output+24576+i),
 	   (simd_q15_t*)(twa18432+i),(simd_q15_t*)(twb18432+i));
   }
+
   if (scale==1) {
     for (i=0; i<288; i++) {
       y128p[0]  = mulhi_int16(y128p[0],ONE_OVER_SQRT3_Q15_128);
@@ -5919,6 +5921,7 @@ void idft18432(int16_t *input, int16_t *output,int scale) {
 
 int16_t twa24576[16384] __attribute__((aligned(32)));
 int16_t twb24576[16384] __attribute__((aligned(32)));
+
 // 8192 x 3
 void dft24576(int16_t *input, int16_t *output,int scale)
 {
@@ -5934,9 +5937,9 @@ void dft24576(int16_t *input, int16_t *output,int scale)
     tmp[2][i] = ((uint32_t *)input)[j++];
   }
 
-  dft8192((int16_t*)(tmp[0]),(int16_t*)(tmpo[0]),1);
-  dft8192((int16_t*)(tmp[1]),(int16_t*)(tmpo[1]),1);
-  dft8192((int16_t*)(tmp[2]),(int16_t*)(tmpo[2]),1);
+  dft8192((int16_t*)(tmp[0]),(int16_t*)(tmpo[0]),scale);
+  dft8192((int16_t*)(tmp[1]),(int16_t*)(tmpo[1]),scale);
+  dft8192((int16_t*)(tmp[2]),(int16_t*)(tmpo[2]),scale);
   /*
   for (i=1; i<8192; i++) {
     tmpo[0][i] = tmpo[0][i<<1];
@@ -5997,9 +6000,9 @@ void idft24576(int16_t *input, int16_t *output,int scale)
     tmp[2][i] = ((uint32_t *)input)[j++];
   }
 
-  idft8192((int16_t*)(tmp[0]),(int16_t*)(tmpo[0]),1);
-  idft8192((int16_t*)(tmp[1]),(int16_t*)(tmpo[1]),1);
-  idft8192((int16_t*)(tmp[2]),(int16_t*)(tmpo[2]),1);
+  idft8192((int16_t*)(tmp[0]),(int16_t*)(tmpo[0]),scale);
+  idft8192((int16_t*)(tmp[1]),(int16_t*)(tmpo[1]),scale);
+  idft8192((int16_t*)(tmp[2]),(int16_t*)(tmpo[2]),scale);
   
   if (LOG_DUMPFLAG(DEBUG_DFT)) {
     LOG_M("idft24576in.m","in",input,24576,1,1);

openair1/PHY/defs_UE.h

@@ -615,6 +615,8 @@ typedef struct {
   //uint8_t local_flag;
   /// \brief Indicator of current run mode of UE (normal_txrx, rx_calib_ue, no_L2_connect, debug_prach)
   runmode_t mode;
+  /// \brief Indicator that UE is configured for FeMBMS functionality
+  int FeMBMS_active;
   /// \brief Indicator that UE should perform band scanning
   int UE_scan;
   /// \brief Indicator that UE should perform coarse scanning around carrier
@@ -698,6 +700,9 @@ typedef struct {
   /// mbsfn reference symbols
   uint32_t lte_gold_mbsfn_table[10][3][42];
 
+  /// [IRTGS 20180731] mbsfn reference symbols for df = 1.25 kHz
+  uint32_t         lte_gold_mbsfn125_table[10][150];
+
   uint32_t X_u[64][839];
 
   uint32_t high_speed_flag;
@@ -881,6 +886,11 @@ typedef struct {
   /// RF and Interface devices per CC
 
   openair0_device rfdevice;
+
+
+  //IRTBL adding counter for subframes SF, because we need 40 ms frame-structure for FeMBMS
+  int SF_count;
+
 } PHY_VARS_UE;
 
 /* this structure is used to pass both UE phy vars and

openair1/PHY/defs_common.h

@@ -678,6 +678,10 @@ typedef struct {
   uint16_t phich_reg[MAX_NUM_PHICH_GROUPS][3];
 
   struct MBSFN_SubframeConfig *mbsfn_SubframeConfig[MAX_MBSFN_AREA];
+
+  // [IRTGS 20180705] additional field in PBCH for MBSFN dedicated ETSI TS 136.321 ch. 6.2.2 r14
+  unsigned int AddNonMBSFN_SF;
+
   /// for fair RR scheduler
   uint32_t ue_multiple_max;
 } LTE_DL_FRAME_PARMS;

openair1/PHY/defs_eNB.h

@@ -1064,6 +1064,9 @@ typedef struct PHY_VARS_eNB_s {
   /// mbsfn reference symbols
   uint32_t         lte_gold_mbsfn_table[10][3][42];
 
+  /// [IRTGS 20180731] mbsfn reference symbols for df = 1.25 kHz
+  uint32_t         lte_gold_mbsfn125_table[10][150];
+
   uint32_t X_u[64][839];
 #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
   uint32_t X_u_br[4][64][839];

openair1/SCHED/fapi_l1.c

@@ -195,22 +195,24 @@ void handle_nfapi_dlsch_pdu(PHY_VARS_eNB *eNB,int frame,int subframe,L1_rxtx_pro
   eNB->pdsch_config_dedicated[UE_id].p_a = rel8->pa;
 
 #ifdef PHY_TX_THREAD
-  if (dlsch0->active[proc->subframe_tx]){
+  if (dlsch0->active[proc->subframe_tx])
 # else
-  if (dlsch0->active){
+  if (dlsch0->active)
 #endif
-    computeRhoA_eNB(rel8->pa, dlsch0,dlsch0_harq->dl_power_off, eNB->frame_parms.nb_antenna_ports_eNB);
-    computeRhoB_eNB(rel8->pa,eNB->frame_parms.pdsch_config_common.p_b,eNB->frame_parms.nb_antenna_ports_eNB,dlsch0,dlsch0_harq->dl_power_off);
-  }
+    {
+      computeRhoA_eNB(rel8->pa, dlsch0,dlsch0_harq->dl_power_off, eNB->frame_parms.nb_antenna_ports_eNB);
+      computeRhoB_eNB(rel8->pa,eNB->frame_parms.pdsch_config_common.p_b,eNB->frame_parms.nb_antenna_ports_eNB,dlsch0,dlsch0_harq->dl_power_off);
+    }
 #ifdef PHY_TX_THREAD
-  if (dlsch1->active[proc->subframe_tx]){
+  if (dlsch1->active[proc->subframe_tx])
 #else
-  if (dlsch1->active){
+  if (dlsch1->active)
 #endif
-    computeRhoA_eNB(rel8->pa, dlsch1,dlsch1_harq->dl_power_off, eNB->frame_parms.nb_antenna_ports_eNB);
-    computeRhoB_eNB(rel8->pa,eNB->frame_parms.pdsch_config_common.p_b,eNB->frame_parms.nb_antenna_ports_eNB,dlsch1,dlsch1_harq->dl_power_off);
-  }
-
+    {
+      computeRhoA_eNB(rel8->pa, dlsch1,dlsch1_harq->dl_power_off, eNB->frame_parms.nb_antenna_ports_eNB);
+      computeRhoB_eNB(rel8->pa,eNB->frame_parms.pdsch_config_common.p_b,eNB->frame_parms.nb_antenna_ports_eNB,dlsch1,dlsch1_harq->dl_power_off);
+    }
+    
   dlsch0_harq->pdsch_start = eNB->pdcch_vars[subframe & 1].num_pdcch_symbols;
 
   if (dlsch0_harq->round==0) {  //get pointer to SDU if this a new SDU
@@ -325,6 +327,20 @@ void handle_nfapi_dlsch_pdu(PHY_VARS_eNB *eNB,int frame,int subframe,L1_rxtx_pro
 #endif
 }
 
+    
+void handle_nfapi_mch_dl_pdu(PHY_VARS_eNB *eNB,int frame,int subframe,L1_rxtx_proc_t *proc,
+			     nfapi_dl_config_request_pdu_t *dl_config_pdu,
+			     uint8_t *sdu) {
+  
+  nfapi_dl_config_mch_pdu_rel8_t *rel8 = &dl_config_pdu->mch_pdu.mch_pdu_rel8;
+
+  AssertFatal(sdu != NULL, "sdu is null\n");
+  fill_eNB_dlsch_MCH(eNB,rel8->modulation,rel8->length<<3);
+  eNB->dlsch_MCH->harq_processes[0]->pdu                    = sdu;
+		     
+}
+  
+
 uint16_t to_beta_offset_harqack[16]={16,20,25,32,40,50,64,80,101,127,160,248,400,640,1008,8};
 
 void handle_ulsch_harq_pdu(
@@ -692,11 +708,20 @@ void schedule_response(Sched_Rsp_t *Sched_INFO)
   nfapi_hi_dci0_request_pdu_t   *hi_dci0_req_pdu;
   nfapi_ul_config_request_pdu_t *ul_config_pdu;
 
+  nfapi_dl_config_dlsch_pdu_rel8_t *dlsch_pdu_rel8;
+  nfapi_dl_config_mch_pdu_rel8_t *mch_pdu_rel8;
+  uint16_t pdu_index;
+  uint16_t tx_pdus;
+  uint16_t invalid_pdu;
+  uint8_t *sdu;
+
+
   int i;
 
   eNB->pdcch_vars[subframe&1].num_pdcch_symbols = number_pdcch_ofdm_symbols;
   eNB->pdcch_vars[subframe&1].num_dci           = 0;
 
+  if (eNB->dlsch_MCH) eNB->dlsch_MCH->active                        = 0;
   LOG_D(PHY,"NFAPI: Sched_INFO:SFN/SF:%04d%d DL_req:SFN/SF:%04d%d:dl_pdu:%d tx_req:SFN/SF:%04d%d:pdus:%d\n",
        frame,subframe,
        NFAPI_SFNSF2SFN(DL_req->sfn_sf),NFAPI_SFNSF2SF(DL_req->sfn_sf),number_dl_pdu,
@@ -755,15 +780,25 @@ void schedule_response(Sched_Rsp_t *Sched_INFO)
                            TX_req->tx_request_body.tx_pdu_list[dl_config_pdu->bch_pdu.bch_pdu_rel8.pdu_index].segments[0].segment_data);
       break;
     case NFAPI_DL_CONFIG_MCH_PDU_TYPE:
-      //      handle_nfapi_mch_dl_pdu(eNB,dl_config_pdu);
+      
+        mch_pdu_rel8 = &dl_config_pdu->mch_pdu.mch_pdu_rel8;
+        pdu_index = mch_pdu_rel8->pdu_index;
+        tx_pdus = TX_req->tx_request_body.number_of_pdus;
+        sdu = (pdu_index!=0)?NULL : TX_req->tx_request_body.tx_pdu_list[pdu_index].segments[0].segment_data;
+	handle_nfapi_mch_dl_pdu(eNB,NFAPI_SFNSF2SFN(DL_req->sfn_sf),NFAPI_SFNSF2SF(DL_req->sfn_sf),proc,dl_config_pdu, sdu);
+        LOG_I(PHY,"%s() [PDU:%d] NFAPI_DL_CONFIG_MCH_PDU_TYPE SFN/SF:%04d%d TX:%d/%d RX:%d/%d pdu_index:%d sdu:%p\n", 
+            __FUNCTION__, i, 
+            NFAPI_SFNSF2SFN(DL_req->sfn_sf),NFAPI_SFNSF2SF(DL_req->sfn_sf),
+            proc->frame_tx, proc->subframe_tx, 
+            proc->frame_rx, proc->subframe_rx, 
+            pdu_index, sdu);
       break;
     case NFAPI_DL_CONFIG_DLSCH_PDU_TYPE:
-      {
-        nfapi_dl_config_dlsch_pdu_rel8_t *dlsch_pdu_rel8 = &dl_config_pdu->dlsch_pdu.dlsch_pdu_rel8;
-        uint16_t pdu_index = dlsch_pdu_rel8->pdu_index;
-        uint16_t tx_pdus = TX_req->tx_request_body.number_of_pdus;
-        uint16_t invalid_pdu = pdu_index == -1;
-        uint8_t *sdu = invalid_pdu ? NULL : pdu_index >= tx_pdus ? NULL : TX_req->tx_request_body.tx_pdu_list[pdu_index].segments[0].segment_data;
+        dlsch_pdu_rel8 = &dl_config_pdu->dlsch_pdu.dlsch_pdu_rel8;
+        pdu_index = dlsch_pdu_rel8->pdu_index;
+        tx_pdus = TX_req->tx_request_body.number_of_pdus;
+        invalid_pdu = pdu_index == -1;
+        sdu = invalid_pdu ? NULL : pdu_index >= tx_pdus ? NULL : TX_req->tx_request_body.tx_pdu_list[pdu_index].segments[0].segment_data;
 
         LOG_D(PHY,"%s() [PDU:%d] NFAPI_DL_CONFIG_DLSCH_PDU_TYPE SFN/SF:%04d%d TX:%d/%d RX:%d/%d transport_blocks:%d pdu_index:%d sdu:%p\n", 
             __FUNCTION__, i, 
@@ -807,7 +842,6 @@ void schedule_response(Sched_Rsp_t *Sched_INFO)
                                            subframe);
 
                                            }        */
-      }
       break;
     case NFAPI_DL_CONFIG_PCH_PDU_TYPE:
       //      handle_nfapi_pch_pdu(eNB,dl_config_pdu);

openair1/SCHED/phy_procedures_lte_eNb.c

@@ -136,14 +136,8 @@ lte_subframe_t get_subframe_direction(uint8_t Mod_id,uint8_t CC_id,uint8_t subfr
 void pmch_procedures(PHY_VARS_eNB *eNB,L1_rxtx_proc_t *proc) {
 
 
-#if (RRC_VERSION >= MAKE_VERSION(10, 0, 0))
-  MCH_PDU *mch_pduP=NULL;
-  //  uint8_t sync_area=255;
-#endif
-
   int subframe = proc->subframe_tx;
 
-  AssertFatal(1==0,"pmch not tested for the moment, exiting\n");
 
   // This is DL-Cell spec pilots in Control region
   generate_pilots_slot(eNB,
@@ -153,29 +147,12 @@ void pmch_procedures(PHY_VARS_eNB *eNB,L1_rxtx_proc_t *proc) {
 
   
 #if (RRC_VERSION >= MAKE_VERSION(10, 0, 0))
-  // if mcch is active, send regardless of the node type: eNB or RN
-  // when mcch is active, MAC sched does not allow MCCH and MTCH multiplexing
-  /*
-  mch_pduP = mac_xface->get_mch_sdu(eNB->Mod_id,
-				    eNB->CC_id,
-				    proc->frame_tx,
-				    subframe);
-  */
-  if ((mch_pduP->Pdu_size > 0) && (mch_pduP->sync_area == 0)) // TEST: only transmit mcch for sync area 0
-    LOG_D(PHY,"[eNB%"PRIu8"] Frame %d subframe %d : Got MCH pdu for MBSFN (MCS %"PRIu8", TBS %d) \n",
-	  eNB->Mod_id,proc->frame_tx,subframe,mch_pduP->mcs,
-	  eNB->dlsch_MCH->harq_processes[0]->TBS>>3);
-  else {
-    LOG_D(PHY,"[DeNB %"PRIu8"] Frame %d subframe %d : Do not transmit MCH pdu for MBSFN sync area %"PRIu8" (%s)\n",
-	  eNB->Mod_id,proc->frame_tx,subframe,mch_pduP->sync_area,
-	  (mch_pduP->Pdu_size == 0)? "Empty MCH PDU":"Let RN transmit for the moment");
-    mch_pduP = NULL;
-  }
-    
-  if (mch_pduP) {
-    fill_eNB_dlsch_MCH(eNB,mch_pduP->mcs,1,0);
+
+  if (eNB->dlsch_MCH->active==1) {
+    AssertFatal(eNB->dlsch_MCH->harq_processes[0]->pdu != NULL,
+		"pdu is null\n");
     // Generate PMCH
-    generate_mch(eNB,proc,(uint8_t*)mch_pduP->payload);
+    generate_mch(eNB,proc);
   } else {
     LOG_D(PHY,"[eNB/RN] Frame %d subframe %d: MCH not generated \n",proc->frame_tx,subframe);
   }
@@ -189,8 +166,12 @@ void common_signal_procedures (PHY_VARS_eNB *eNB,int frame, int subframe) {
   int **txdataF = eNB->common_vars.txdataF;
   uint8_t *pbch_pdu=&eNB->pbch_pdu[0];
 
-  LOG_D(PHY,"common_signal_procedures: frame %d, subframe %d fdd:%s dir:%s\n",frame,subframe,fp->frame_type == FDD?"FDD":"TDD", subframe_select(fp,subframe) == SF_DL?"DL":"UL?"); 
 
+  // AssertFatal((eNB->FeMBMS_active == 1) && ((frame&3 != 0) || (subframe > 0)),"Called common_signal_procedures for FeMBMS subframe which is not regular LTE\n");
+
+  //LOG_D(PHY,"common_signal_procedures: frame %d, subframe %d fdd:%s dir:%s\n",frame,subframe,fp->frame_type == FDD?"FDD":"TDD", subframe_select(fp,subframe) == SF_DL?"DL":"UL?"); 
+
+  // if ((eNB->FeMBMS_active ==0) || ((eNB->FeMBMS_active == 1) && ((frame % 4) == 0)) {
   // generate Cell-Specific Reference Signals for both slots
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_RS_TX,1);
 
@@ -237,7 +218,7 @@ void common_signal_procedures (PHY_VARS_eNB *eNB,int frame, int subframe) {
 
       
     /// First half of SSS (TDD, slot 1)
-    
+    // if ((eNB->FeMBMS_active==0) && (fp->frame_type == TDD))
     if (fp->frame_type == TDD) {
       generate_sss(txdataF,
 		   AMP,
@@ -249,16 +230,20 @@ void common_signal_procedures (PHY_VARS_eNB *eNB,int frame, int subframe) {
     // generate PBCH (Physical Broadcast CHannel) info
 
     /// generate PBCH
+
+    // if (((eNB->FeMBMS_active == 1) && ((frame&15) ==  0)) || (eNB->FeMBMS_active == 0) && ((frame&3)==0)) {
     if ((frame&3)==0) {
       //AssertFatal(eNB->pbch_configured==1,"PBCH was not configured by MAC\n");
       if (eNB->pbch_configured!=1) return;
       eNB->pbch_configured=0;
     }
+    // if (eNB->FeMBMS_active == 1) && (frame&3==0)) || (eNB->FeMBMS_active == 0)
     generate_pbch(&eNB->pbch,
 		  txdataF,
 		  AMP,
 		  fp,
 		  pbch_pdu,
+		  // eNB->FeMBMS_active == 1 ? (frame>>2)&3 : frame&3
 		  frame&3);
   
   }

openair1/SCHED/ru_procedures.c

@@ -455,7 +455,7 @@ void feptx_prec(RU_t *ru) {
 	} //if (p<fp->nb_antenna_ports_eNB)
 	
 	  // PDSCH region
-	if (p<fp->nb_antenna_ports_eNB || p==5 || p==7 || p==8) {
+	if (p<fp->nb_antenna_ports_eNB || p==4 || p==5 || p==7 || p==8) {
 	  for (l=pdcch_vars->num_pdcch_symbols;l<fp->symbols_per_tti;l++) {
 	    beam_precoding(eNB->common_vars.txdataF,
 			   ru->common.txdataF_BF,

openair1/SCHED_UE/phy_procedures_lte_ue.c

@@ -2582,6 +2582,18 @@ void ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uin
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_PBCH_PROCEDURES, VCD_FUNCTION_IN);
 
+  // In general we will need to detect that the UE is running with FeMBMS
+  // something like if (ue->FeMBMS_active == 1)
+  // This is for regular LTE
+  // for FeMBMS this has to be something like:
+  //  AssertFatal(frame_rx&3 == 0, "ue_pbch_procedures called in frame that is not a multiple of 4\n");
+  //  pbch_phase_FeMBMS = (frame_rx/4)&3;
+ 
+  // [IRTGS 20180622] *********************************************************************
+  // pbch_phase=((frame_rx>>2)&3);
+  // printf("\x1B[1;34m[IRTGS]: \x1B[0m"); // blue
+  // printf("\x1B[32m%s%d\x1B[0m\n","[ue_pbch_procedures]: pbch_phase = ", pbch_phase);
+
   pbch_phase=(frame_rx%4);
 
   if (pbch_phase>=4)
@@ -2591,13 +2603,28 @@ void ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uin
     //for (pbch_phase=0;pbch_phase<4;pbch_phase++) {
     //LOG_I(PHY,"[UE  %d] Frame %d, Trying PBCH %d (NidCell %d, eNB_id %d)\n",ue->Mod_id,frame_rx,pbch_phase,ue->frame_parms.Nid_cell,eNB_id);
 
-    pbch_tx_ant = rx_pbch(&ue->common_vars,
+// [IRTGS 20180622] Testweise rx_pbch_125 genommen...**************************************
+//printf("\x1B[1;34m[IRTGS]: \x1B[0m"); // blue
+//printf("\x1B[32m%s\x1B[0m\n","[ue_pbch_procedures]: calling rx_pbch_125");
+
+    if (ue->FeMBMS_active == 2) // FeMBMS dedicated
+    { pbch_tx_ant = rx_pbch_125(&ue->common_vars,
 			  ue->pbch_vars[eNB_id],
 			  &ue->frame_parms,
 			  eNB_id,
 			  ue->frame_parms.nb_antenna_ports_eNB==1?SISO:ALAMOUTI,
 			  ue->high_speed_flag,
 			  pbch_phase);
+    } else
+    { pbch_tx_ant = rx_pbch(&ue->common_vars,
+			  ue->pbch_vars[eNB_id],
+			  &ue->frame_parms,
+			  eNB_id,
+			  ue->frame_parms.nb_antenna_ports_eNB==1?SISO:ALAMOUTI,
+			  ue->high_speed_flag,
+			  pbch_phase);
+    }    
+
     
     if ((pbch_tx_ant>0) && (pbch_tx_ant<=4)) {
       break;
@@ -2609,8 +2636,6 @@ void ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uin
       pbch_phase=0;
   }
 
-
-
   if ((pbch_tx_ant>0) && (pbch_tx_ant<=4)) {
 
     if (opt_enabled) {
@@ -2630,11 +2655,36 @@ void ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uin
       return;
     }
 
-
     ue->pbch_vars[eNB_id]->pdu_errors_conseq = 0;
-    frame_tx = (((int)(ue->pbch_vars[eNB_id]->decoded_output[2]&0x03))<<8);
-    frame_tx += ((int)(ue->pbch_vars[eNB_id]->decoded_output[1]&0xfc));
-    frame_tx += pbch_phase;
+
+    // [IRTGS 20180709] frame_tx is just used to store frame_rx as the old frame_rx is needed later
+    // [IRTGS 20180709] decision for FeMBMS_active included
+
+printf("\x1B[1;34m[IRTGS]: \x1B[0m"); // blue
+
+    if (ue->FeMBMS_active == 2) // FeMBMS dedicated  ***ASSUMPTION***
+    { // Assumption 1: frame_rx follows directly after N_RB_DL
+      frame_tx  = (int)((ue->pbch_vars[eNB_id]->decoded_output[2]&31)<<1);
+      frame_tx += ue->pbch_vars[eNB_id]->decoded_output[1]>>7;
+      frame_tx  = frame_tx <<4;  
+      
+      // Assumption 2: frame _rx begins at the same location but just uses the first 6 bits
+      // frame_tx = (((int)(ue->pbch_vars[eNB_id]->decoded_output[2]&0x03))<<8);
+      // frame_tx += ((int)(ue->pbch_vars[eNB_id]->decoded_output[1]&0xf0)); // 0xF0 instead of 0XFC
+      
+      frame_tx += 4*pbch_phase;
+
+printf("\x1B[32m%s%d%s%d\x1B[0m","[ue_pbch_procedures FeMBMS]: frame_rx = ",frame_tx,"  pbch_phase = ", pbch_phase);
+
+    } else // 'normal' LTE
+    {
+      frame_tx = (((int)(ue->pbch_vars[eNB_id]->decoded_output[2]&0x03))<<8);
+      frame_tx += ((int)(ue->pbch_vars[eNB_id]->decoded_output[1]&0xfc));
+      frame_tx += pbch_phase;
+printf("\x1B[32m%s%d%s%d\x1B[0m","[ue_pbch_procedures reg.LTE]: frame_rx = ",frame_tx,"  pbch_phase = ", pbch_phase);
+    }
+
+printf("\x1B[32m%s%X\x1B[0m\n","  pbch_tx_ant = 0x",pbch_tx_ant);
 
     if (ue->mac_enabled==1) {
 
@@ -2714,6 +2764,7 @@ void ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uin
       LOG_E(PHY,"[UE %d] frame %d, subframe %d, Error decoding PBCH!\n",
       ue->Mod_id,frame_rx, subframe_rx);
 
+
       LOG_I(PHY,"[UE %d] rx_offset %d\n",ue->Mod_id,ue->rx_offset);
 
 
@@ -3900,6 +3951,9 @@ void *UE_thread_slot1_dl_processing(void *arg) {
         next_subframe_rx    = (1+subframe_rx)%10;
         next_subframe_slot0 = next_subframe_rx<<1;
 
+	// additional check for FeMBMS
+	// if  ((ue->FeMBMS_active ==0) || ((ue->FeMBMS_active == 1) && ((frame_rx % 4) == 0)) {
+
         slot1  = (subframe_rx<<1) + 1;
         pilot0 = 0;
 
@@ -3993,6 +4047,7 @@ void *UE_thread_slot1_dl_processing(void *arg) {
                 next_subframe_slot0,
                 0);
 
+
         if ( (subframe_rx == 0) && (ue->decode_MIB == 1))
         {
             ue_pbch_procedures(0,ue,proc,0);
@@ -4114,6 +4169,7 @@ void *UE_thread_slot1_dl_processing(void *arg) {
             LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE FEP Slo1\n" );
             exit_fun("noting to add");
         }
+	// } end condition for FeMBMS
     }
     // thread finished
         free(arg);

openair1/SIMULATION/LTE_PHY/dlsim.c

@@ -164,7 +164,8 @@ void do_OFDM_mod_l(int32_t **txdataF, int32_t **txdata, uint16_t next_slot, LTE_
 
 }
 
-void DL_channel(RU_t *ru,PHY_VARS_UE *UE,uint subframe,int awgn_flag,double SNR, int tx_lev,int hold_channel,int abstx, int num_rounds, int trials, int round, channel_desc_t *eNB2UE[4],
+void DL_channel(RU_t *ru,PHY_VARS_UE *UE,uint subframe,int awgn_flag,double SNR, int tx_lev,int hold_channel,int abstx, int num_rounds, int
+ trials, int round, channel_desc_t *eNB2UE[4],
 		double *s_re[2],double *s_im[2],double *r_re[2],double *r_im[2],FILE *csv_fd) {
 
   int i,u;
@@ -179,6 +180,8 @@ void DL_channel(RU_t *ru,PHY_VARS_UE *UE,uint subframe,int awgn_flag,double SNR,
       if (awgn_flag == 0) {
 	s_re[aa][i] = ((double)(((short *)ru->common.txdata[aa]))[(2*subframe*UE->frame_parms.samples_per_tti) + (i<<1)]);
 	s_im[aa][i] = ((double)(((short *)ru->common.txdata[aa]))[(2*subframe*UE->frame_parms.samples_per_tti) +(i<<1)+1]);
+
+
       } else {
 	for (aarx=0; aarx<UE->frame_parms.nb_antennas_rx; aarx++) {
 	  if (aa==0) {
@@ -538,7 +541,7 @@ int n_users = 1;
 sub_frame_t subframe=7;
 int num_common_dci=0,num_ue_spec_dci=0,num_dci=0,num_pdcch_symbols=1;
 uint16_t n_rnti=0x1234;
-  int nfapi_mode=0;
+int nfapi_mode=0;
 
 int main(int argc, char **argv)
 {
@@ -1443,7 +1446,7 @@ int main(int argc, char **argv)
       eNB->UE_stats[1].DL_pmi_single = 0;
   }
 
-  L1_rxtx_proc_t *proc_eNB = &eNB->proc.proc_rxtx[0];//UE->current_thread_id[subframe]];
+  L1_rxtx_proc_t *proc_eNB = &eNB->proc.L1_proc;
 
   if (input_fd==NULL) {
 

openair1/SIMULATION/LTE_PHY/dummy_functions.c

@@ -60,9 +60,14 @@ 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){}
 
+int mch_mcs;
 int ue_query_mch(module_id_t Mod_id, uint8_t CC_id, uint32_t frame,
 		 sub_frame_t subframe, uint8_t eNB_index,
-		 uint8_t * sync_area, uint8_t * mcch_active){ return(0);}
+		 uint8_t * sync_area, uint8_t * mcch_active){ 
+  *mcch_active=0;
+  *sync_area = 0;
+  return(mch_mcs);
+}
 
 void dl_phy_sync_success(module_id_t module_idP,
 			 frame_t frameP,

openair1/SIMULATION/LTE_PHY/mbmssim.c

@@ -26,14 +26,25 @@
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
-#include "SIMULATION/TOOLS/defs.h"
-#include "SIMULATION/RF/defs.h"
+#include "SIMULATION/TOOLS/sim.h"
+#include "SIMULATION/RF/rf.h"
 #include "PHY/types.h"
-#include "PHY/defs.h"
-#include "PHY/vars.h"
-#include "SCHED/defs.h"
-#include "SCHED/vars.h"
-#include "LAYER2/MAC/vars.h"
+#include "PHY/defs_eNB.h"
+#include "PHY/defs_UE.h"
+#include "PHY/phy_vars.h"
+#include "PHY/phy_vars_ue.h"
+#include "SCHED/sched_common_vars.h"
+#include "LAYER2/MAC/mac_vars.h"
+
+#include "PHY/MODULATION/modulation_common.h"
+#include "PHY/MODULATION/modulation_eNB.h"
+#include "PHY/MODULATION/modulation_UE.h"
+#include "PHY/LTE_TRANSPORT/transport_proto.h"
+#include "PHY/LTE_UE_TRANSPORT/transport_proto_ue.h"
+#include "SCHED/sched_eNB.h"
+#include "SCHED_UE/sched_UE.h"
+#include "common/config/config_load_configmodule.h"
+#include "PHY/INIT/phy_init.h"
 
 #ifdef XFORMS
 #include "PHY/TOOLS/lte_phy_scope.h"
@@ -42,60 +53,207 @@
 
 #include "OCG_vars.h"
 #include "unitary_defs.h"
+#include "dummy_functions.c"
 
 
-PHY_VARS_eNB *eNB;
-PHY_VARS_UE *UE;
+
+void feptx_ofdm(RU_t *ru);
+void feptx_prec(RU_t *ru);
 
 double cpuf;
 
-DCI1E_5MHz_2A_M10PRB_TDD_t  DLSCH_alloc_pdu2_1E[2];
-#define UL_RB_ALLOC 0x1ff;
-#define CCCH_RB_ALLOC computeRIV(eNB->frame_parms.N_RB_UL,0,2)
+
+
+uint16_t m_rnti=0x1234;
+int nfapi_mode=0;
+int codingw = 0;
+int emulate_rf = 0;
+extern int mch_mcs;
+
+void DL_channel(RU_t *ru,PHY_VARS_UE *UE,uint subframe,int awgn_flag,double SNR, int tx_lev,int hold_channel,int trials, 
+		  channel_desc_t *eNB2UE,
+		  double *s_re[2],double *s_im[2],double *r_re[2],double *r_im[2]) {
+
+  int i;
+  int aa,aarx;
+  double sigma2_dB,sigma2;
+  double iqim=0.0;
+
+  //    printf("Copying tx ..., nsymb %d (n_tx %d), awgn %d\n",nsymb,eNB->frame_parms.nb_antennas_tx,awgn_flag);
+  for (i=0; i<2*UE->frame_parms.samples_per_tti; i++) {
+    for (aa=0; aa<ru->frame_parms.nb_antennas_tx; aa++) {
+      if (awgn_flag == 0) {
+	s_re[aa][i] = ((double)(((short *)ru->common.txdata[aa]))[(2*subframe*UE->frame_parms.samples_per_tti) + (i<<1)]);
+	s_im[aa][i] = ((double)(((short *)ru->common.txdata[aa]))[(2*subframe*UE->frame_parms.samples_per_tti) +(i<<1)+1]);
+
+
+      } else {
+	for (aarx=0; aarx<UE->frame_parms.nb_antennas_rx; aarx++) {
+	  if (aa==0) {
+	    r_re[aarx][i] = ((double)(((short *)ru->common.txdata[aa]))[(2*subframe*UE->frame_parms.samples_per_tti) +(i<<1)]);
+	    r_im[aarx][i] = ((double)(((short *)ru->common.txdata[aa]))[(2*subframe*UE->frame_parms.samples_per_tti) +(i<<1)+1]);
+	  } else {
+	    r_re[aarx][i] += ((double)(((short *)ru->common.txdata[aa]))[(2*subframe*UE->frame_parms.samples_per_tti) +(i<<1)]);
+	    r_im[aarx][i] += ((double)(((short *)ru->common.txdata[aa]))[(2*subframe*UE->frame_parms.samples_per_tti) +(i<<1)+1]);
+	  }
+
+	}
+      }
+    }
+  }
+
+  // Multipath channel
+  if (awgn_flag == 0) {
+    multipath_channel(eNB2UE,s_re,s_im,r_re,r_im,
+		      2*UE->frame_parms.samples_per_tti,hold_channel);
+
+
+
+    if (UE->perfect_ce==1) {
+      // fill in perfect channel estimates
+      freq_channel(eNB2UE,UE->frame_parms.N_RB_DL,12*UE->frame_parms.N_RB_DL + 1);
+    }
+  }
+
+
+  //AWGN
+  // tx_lev is the average energy over the whole subframe
+  // but SNR should be better defined wrt the energy in the reference symbols
+  sigma2_dB = 10*log10((double)tx_lev) +10*log10((double)ru->frame_parms.ofdm_symbol_size/(double)(ru->frame_parms.N_RB_DL*12)) - SNR;
+  sigma2 = pow(10,sigma2_dB/10);
+
+  for (i=0; i<2*UE->frame_parms.samples_per_tti; i++) {
+    for (aa=0; aa<UE->frame_parms.nb_antennas_rx; aa++) {
+      //printf("s_re[0][%d]=> %f , r_re[0][%d]=> %f\n",i,s_re[aa][i],i,r_re[aa][i]);
+      ((short*) UE->common_vars.rxdata[aa])[(2*subframe*UE->frame_parms.samples_per_tti)+2*i] =
+	(short) (r_re[aa][i] + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
+      ((short*) UE->common_vars.rxdata[aa])[(2*subframe*UE->frame_parms.samples_per_tti)+2*i+1] =
+	(short) (r_im[aa][i] + (iqim*r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
+    }
+  }
+}
+
+
+uint16_t
+fill_tx_req(nfapi_tx_request_body_t *tx_req_body,
+	    uint16_t                absSF,
+	    uint16_t                pdu_length,
+	    uint16_t                pdu_index,
+	    uint8_t                 *pdu)
+{
+  nfapi_tx_request_pdu_t *TX_req = &tx_req_body->tx_pdu_list[tx_req_body->number_of_pdus];
+  LOG_D(MAC, "Filling TX_req %d for pdu length %d\n",
+	tx_req_body->number_of_pdus, pdu_length);
+
+  TX_req->pdu_length                 = pdu_length;
+  TX_req->pdu_index                  = pdu_index;
+  TX_req->num_segments               = 1;
+  TX_req->segments[0].segment_length = pdu_length;
+  TX_req->segments[0].segment_data   = pdu;
+  tx_req_body->tl.tag                = NFAPI_TX_REQUEST_BODY_TAG;
+  tx_req_body->number_of_pdus++;
+
+  return (((absSF / 10) << 4) + (absSF % 10));
+}
+
+void fill_MCH_config(PHY_VARS_eNB *eNB,
+		     int frame,
+		     int subframe,
+		     Sched_Rsp_t *sched_resp,
+		     uint8_t input_buffer[20000],
+		     int mcs,
+		     int mbsfn_id,
+		     int m_rnti,
+		     int NB_RB,
+		     int MCH_RB_ALLOC) {
+
+
+  nfapi_dl_config_request_body_t *dl_req=&sched_resp->DL_req->dl_config_request_body;
+  nfapi_tx_request_body_t        *TX_req=&sched_resp->TX_req->tx_request_body;
+
+  dl_req->number_dci=0;
+  dl_req->number_pdu=0;
+  TX_req->number_of_pdus=0;
+  dl_req->tl.tag = NFAPI_DL_CONFIG_REQUEST_BODY_TAG;
+
+  nfapi_dl_config_request_pdu_t *dl_config_pdu = &dl_req->dl_config_pdu_list[dl_req->number_pdu];
+
+  memset((void *) dl_config_pdu, 0,
+	 sizeof(nfapi_dl_config_request_pdu_t));
+
+  dl_config_pdu->pdu_type                                                    = NFAPI_DL_CONFIG_MCH_PDU_TYPE;
+  dl_config_pdu->pdu_size                                                    = (uint8_t) (2 + sizeof(nfapi_dl_config_mch_pdu));
+
+  dl_config_pdu->mch_pdu.mch_pdu_rel8.tl.tag                                 = NFAPI_DL_CONFIG_REQUEST_MCH_PDU_REL8_TAG;
+  dl_config_pdu->mch_pdu.mch_pdu_rel8.length                                 = get_TBS_DL(mcs,NB_RB);
+  dl_config_pdu->mch_pdu.mch_pdu_rel8.pdu_index                              = 0;
+  dl_config_pdu->mch_pdu.mch_pdu_rel8.rnti                                   = m_rnti;
+  dl_config_pdu->mch_pdu.mch_pdu_rel8.resource_allocation_type               = 0;
+  dl_config_pdu->mch_pdu.mch_pdu_rel8.resource_block_coding                  = MCH_RB_ALLOC;
+  dl_config_pdu->mch_pdu.mch_pdu_rel8.modulation                             = get_Qm(mcs);
+  dl_config_pdu->mch_pdu.mch_pdu_rel8.mbsfn_area_id                          = mbsfn_id;
+  dl_req->number_pdu++;
+  fill_tx_req(TX_req,
+	      (frame * 10) + subframe,
+	      get_TBS_DL(mcs,NB_RB),
+	      0,
+	      input_buffer);
+ 
+  eNB->frame_parms.Nid_cell_mbsfn = mbsfn_id;
+}
+
+
 int main(int argc, char **argv)
 {
 
   char c;
 
-  int i,l,l2,aa,aarx,k;
-  double sigma2, sigma2_dB=0,SNR,snr0=-2.0,snr1=0.0;
+  int i,aa;
+  double SNR,snr0=-2.0,snr1=0.0;
   uint8_t snr1set=0;
   double snr_step=1,input_snr_step=1;
-  int **txdata;
   double s_re0[2*30720],s_im0[2*30720],s_re1[2*30720],s_im1[2*30720];
   double r_re0[2*30720],r_im0[2*30720],r_re1[2*30720],r_im1[2*30720];
   double *s_re[2]={s_re0,s_re1},*s_im[2]={s_im0,s_im1},*r_re[2]={r_re0,r_re1},*r_im[2]={r_im0,r_im1};
-  double iqim = 0.0;
   int subframe=1;
   char fname[40];//, vname[40];
   uint8_t transmission_mode = 1,n_tx=1,n_rx=2;
   uint16_t Nid_cell=0;
+  uint16_t mbsfn_id=0;
 
   FILE *fd;
 
-  int eNB_id = 0;
-  unsigned char mcs=0,awgn_flag=0,round;
+  unsigned char mcs=0,awgn_flag=0;
 
   int n_frames=1;
   channel_desc_t *eNB2UE;
   uint32_t nsymb,tx_lev,tx_lev_dB;
-  uint8_t extended_prefix_flag=1;
   LTE_DL_FRAME_PARMS *frame_parms;
   int hold_channel=0;
 
 
   uint16_t NB_RB=25;
+  int MCH_RB_ALLOC = 0;
 
   int tdd_config=3;
 
   SCM_t channel_model=MBSFN;
+  PHY_VARS_eNB *eNB;
+  RU_t *ru;
+  PHY_VARS_UE *UE;
 
+  nfapi_dl_config_request_t DL_req;
+  nfapi_ul_config_request_t UL_req;
+  nfapi_hi_dci0_request_t HI_DCI0_req;
+  nfapi_dl_config_request_pdu_t dl_config_pdu_list[MAX_NUM_DL_PDU];
+  nfapi_tx_request_pdu_t tx_pdu_list[MAX_NUM_TX_REQUEST_PDU];
+  nfapi_tx_request_t TX_req;
+  Sched_Rsp_t sched_resp;
 
   unsigned char *input_buffer;
   unsigned short input_buffer_length;
-  unsigned int ret;
 
-  unsigned int trials,errs[4]= {0,0,0,0}; //,round_trials[4]={0,0,0,0};
+  unsigned int trials;
 
   uint8_t N_RB_DL=25,osf=1;
   uint32_t perfect_ce = 0;
@@ -104,8 +262,10 @@ int main(int argc, char **argv)
 
   uint32_t Nsoft = 1827072;
 
+
+
   /*
-#ifdef XFORMS
+    #ifdef XFORMS
   FD_lte_phy_scope_ue *form_ue;
   char title[255];
 
@@ -118,8 +278,19 @@ int main(int argc, char **argv)
 
   cpuf = get_cpu_freq_GHz();
 
-  logInit();
-  number_of_cards = 1;
+  memset((void*)&sched_resp,0,sizeof(sched_resp));
+  sched_resp.DL_req = &DL_req;
+  sched_resp.UL_req = &UL_req;
+  sched_resp.HI_DCI0_req = &HI_DCI0_req;
+  sched_resp.TX_req = &TX_req;
+  memset((void*)&DL_req,0,sizeof(DL_req));
+  memset((void*)&UL_req,0,sizeof(UL_req));
+  memset((void*)&HI_DCI0_req,0,sizeof(HI_DCI0_req));
+  memset((void*)&TX_req,0,sizeof(TX_req));
+
+  DL_req.dl_config_request_body.dl_config_pdu_list = dl_config_pdu_list;
+  TX_req.tx_request_body.tx_pdu_list = tx_pdu_list;
+
 
   while ((c = getopt (argc, argv, "ahA:Cp:n:s:S:t:x:y:z:N:F:R:O:dm:i:Y")) != -1) {
     switch (c) {
@@ -224,6 +395,29 @@ int main(int argc, char **argv)
   if (awgn_flag == 1)
     channel_model = AWGN;
 
+  mch_mcs = mcs;
+
+  switch (N_RB_DL) {
+  case 6:
+    MCH_RB_ALLOC = 0x3f;
+
+    break;
+    
+  case 25:
+    MCH_RB_ALLOC = 0x1fff;
+    break;
+    
+  case 50:
+    MCH_RB_ALLOC = 0x1ffff;
+    break;
+    
+  case 100:
+    MCH_RB_ALLOC = 0x1ffffff;
+    break;
+  }
+  
+  NB_RB=conv_nprb(0,MCH_RB_ALLOC,N_RB_DL);
+  
   // check that subframe is legal for eMBMS
 
   if ((subframe == 0) || (subframe == 5) ||    // TDD and FDD SFn 0,5;
@@ -237,19 +431,36 @@ int main(int argc, char **argv)
   if (transmission_mode==2)
     n_tx=2;
 
-  lte_param_init(n_tx,
+  AssertFatal(load_configmodule(argc,argv) != NULL,
+	      "cannot load configuration module, exiting\n");
+  logInit();
+  set_glog(LOG_INFO);
+
+  RC.nb_L1_inst = 1;
+  RC.nb_RU = 1;
+
+  lte_param_init(&eNB,&UE,&ru,
+		 n_tx,
                  n_tx,
+		 1,
 		 n_rx,
 		 transmission_mode,
-		 extended_prefix_flag,
-		 frame_type,
+		 1,
+		 FDD,
 		 Nid_cell,
 		 tdd_config,
 		 N_RB_DL,
 		 0,
+		 0,
 		 osf,
 		 perfect_ce);
 
+  RC.eNB = (PHY_VARS_eNB ***)malloc(sizeof(PHY_VARS_eNB **));
+  RC.eNB[0] = (PHY_VARS_eNB **)malloc(sizeof(PHY_VARS_eNB *));
+  RC.ru = (RU_t **)malloc(sizeof(RC.ru));
+  RC.eNB[0][0] = eNB;
+  RC.ru[0] = ru;
+
   if (snr1set==0) {
     if (n_frames==1)
       snr1 = snr0+.1;
@@ -285,7 +496,6 @@ int main(int argc, char **argv)
 
   fflush(fd);
 
-  txdata = eNB->common_vars.txdata[0];
 
   nsymb = 12;
 
@@ -322,8 +532,11 @@ int main(int argc, char **argv)
   UE->frame_parms.MBSFN_config[0].fourFrames_flag = 0;
   UE->frame_parms.MBSFN_config[0].mbsfn_SubframeConfig=0xff; // activate all possible subframes
 
-  fill_eNB_dlsch_MCH(eNB,mcs,1,0);
+  //  fill_eNB_dlsch_MCH(eNB,mcs,1,0);
   fill_UE_dlsch_MCH(UE,mcs,1,0,0);
+  UE->frame_parms.Nid_cell_mbsfn = mbsfn_id;
+
+  eNB_rxtx_proc_t *proc_eNB = &eNB->proc.proc_rxtx[0];//UE->current_thread_id[subframe]];
 
   if (is_pmch_subframe(0,subframe,&eNB->frame_parms)==0) {
     printf("eNB is not configured for MBSFN in subframe %d\n",subframe);
@@ -343,45 +556,52 @@ int main(int argc, char **argv)
   }
 
 
+  fill_MCH_config(eNB,0,1,&sched_resp,input_buffer,mcs,mbsfn_id,m_rnti,NB_RB,MCH_RB_ALLOC);
+
   snr_step = input_snr_step;
 
   for (SNR=snr0; SNR<snr1; SNR+=snr_step) {
     UE->proc.proc_rxtx[0].frame_tx=0;
+    UE->proc.proc_rxtx[UE->current_thread_id[subframe]].frame_rx=0;
     eNB->proc.proc_rxtx[0].frame_tx=0;
     eNB->proc.proc_rxtx[0].subframe_tx=subframe;
 
-    errs[0]=0;
-    errs[1]=0;
-    errs[2]=0;
-    errs[3]=0;
-    /*
-    round_trials[0] = 0;
-    round_trials[1] = 0;
-    round_trials[2] = 0;
-    round_trials[3] = 0;*/
+    UE->dlsch_mtch_errors[0][0]=0;
+
     printf("********************** SNR %f (step %f)\n",SNR,snr_step);
 
     for (trials = 0; trials<n_frames; trials++) {
       //        printf("Trial %d\n",trials);
       fflush(stdout);
-      round=0;
-
-      //if (trials%100==0)
-      //eNB2UE[0]->first_run = 1;
-      eNB2UE->first_run = 1;
-      memset(&eNB->common_vars.txdataF[0][0][0],0,FRAME_LENGTH_COMPLEX_SAMPLES_NO_PREFIX*sizeof(int32_t));
-      generate_mch(eNB,&eNB->proc.proc_rxtx[0],input_buffer);
 
 
-      PHY_ofdm_mod(eNB->common_vars.txdataF[0][0],        // input,
-                   txdata[0],         // output
-                   frame_parms->ofdm_symbol_size,
-                   LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*nsymb,                 // number of symbols
-                   frame_parms->nb_prefix_samples,               // number of prefix samples
-                   CYCLIC_PREFIX);
+      DL_req.sfn_sf = (proc_eNB->frame_tx<<4)+subframe;
+      TX_req.sfn_sf = (proc_eNB->frame_tx<<4)+subframe;
 
+      proc_eNB->subframe_tx = subframe;
+      sched_resp.subframe=subframe;
+      sched_resp.frame=proc_eNB->frame_tx;
+      
+      eNB->abstraction_flag=0;
+      schedule_response(&sched_resp);
+      phy_procedures_eNB_TX(eNB,proc_eNB,1);
+      
+      ru->proc.subframe_tx=subframe;
+      ru->do_precoding=1;
+
+      feptx_prec(ru);
+      feptx_ofdm(ru);
+      
+      
+      proc_eNB->frame_tx++;
+      
+      
       if (n_frames==1) {
-        LOG_M("txsigF0.m","txsF0", &eNB->common_vars.txdataF[0][0][subframe*nsymb*eNB->frame_parms.ofdm_symbol_size],
+        LOG_M("txsigF0.m","txsF0", &eNB->common_vars.txdataF[0][subframe*nsymb*eNB->frame_parms.ofdm_symbol_size],
+                     nsymb*eNB->frame_parms.ofdm_symbol_size,1,1);
+        LOG_M("txsigF4.m","txsF4", &eNB->common_vars.txdataF[4][subframe*nsymb*eNB->frame_parms.ofdm_symbol_size],
+                     nsymb*eNB->frame_parms.ofdm_symbol_size,1,1);
+        LOG_M("txsigF_BF.m","txsF_BF", &ru->common.txdataF_BF[0][0],
                      nsymb*eNB->frame_parms.ofdm_symbol_size,1,1);
         //if (eNB->frame_parms.nb_antennas_tx>1)
         //LOG_M("txsigF1.m","txsF1", &eNB->lte_eNB_common_vars.txdataF[eNB_id][1][subframe*nsymb*eNB->frame_parms.ofdm_symbol_size],nsymb*eNB->frame_parms.ofdm_symbol_size,1,1);
@@ -390,11 +610,12 @@ int main(int argc, char **argv)
       tx_lev = 0;
 
       for (aa=0; aa<eNB->frame_parms.nb_antennas_tx; aa++) {
-        tx_lev += signal_energy(&eNB->common_vars.txdata[eNB_id][aa]
+        tx_lev += signal_energy(&ru->common.txdata[aa]
                                 [subframe*eNB->frame_parms.samples_per_tti],
                                 eNB->frame_parms.samples_per_tti);
       }
 
+
       tx_lev_dB = (unsigned int) dB_fixed(tx_lev);
 
       if (n_frames==1) {
@@ -404,124 +625,44 @@ int main(int argc, char **argv)
         //     eNB->frame_parms.samples_per_tti,1,1);
       }
 
+      DL_channel(ru,UE,subframe,awgn_flag,SNR,tx_lev,hold_channel,trials,eNB2UE,s_re,s_im,r_re,r_im);
+      
+      
+      UE_rxtx_proc_t *proc = &UE->proc.proc_rxtx[UE->current_thread_id[subframe]];
+      proc->subframe_rx = subframe;
+      UE->UE_mode[0] = PUSCH;
+      
+      slot_fep_mbsfn(UE,
+		     0,
+		     proc->subframe_rx,
+		     UE->rx_offset,
+		     0);
 
-      for (i=0; i<2*frame_parms->samples_per_tti; i++) {
-        for (aa=0; aa<eNB->frame_parms.nb_antennas_tx; aa++) {
-          s_re[aa][i] = ((double)(((short *)eNB->common_vars.txdata[0][aa]))[(2*subframe*UE->frame_parms.samples_per_tti) + (i<<1)]);
-          s_im[aa][i] = ((double)(((short *)eNB->common_vars.txdata[0][aa]))[(2*subframe*UE->frame_parms.samples_per_tti) +(i<<1)+1]);
-        }
-      }
+      if (n_frames==1) printf("Running phy_procedures_UE_RX\n");
+      phy_procedures_UE_RX(UE,proc,0,0,0,normal_txrx);
 
-      //Multipath channel
-      multipath_channel(eNB2UE,s_re,s_im,r_re,r_im,
-                        2*frame_parms->samples_per_tti,hold_channel);
-
-      //AWGN
-      sigma2_dB = 10*log10((double)tx_lev) +10*log10((double)eNB->frame_parms.ofdm_symbol_size/(NB_RB*12)) - SNR;
-      sigma2 = pow(10,sigma2_dB/10);
-
-      if (n_frames==1)
-        printf("Sigma2 %f (sigma2_dB %f)\n",sigma2,sigma2_dB);
-
-      for (i=0; i<2*frame_parms->samples_per_tti; i++) {
-        for (aa=0; aa<eNB->frame_parms.nb_antennas_rx; aa++) {
-          //printf("s_re[0][%d]=> %f , r_re[0][%d]=> %f\n",i,s_re[aa][i],i,r_re[aa][i]);
-          ((short*) UE->common_vars.rxdata[aa])[(2*subframe*UE->frame_parms.samples_per_tti)+2*i] =
-            (short) (r_re[aa][i] + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
-          ((short*) UE->common_vars.rxdata[aa])[(2*subframe*UE->frame_parms.samples_per_tti)+2*i+1] =
-            (short) (r_im[aa][i] + (iqim*r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
-        }
-      }
-
-      for (l=2; l<12; l++) {
-
-        slot_fep_mbsfn(UE,
-                       l,
-                       subframe%10,
-                       0,
-                       0);
-	if (UE->perfect_ce==1) {
-	  // fill in perfect channel estimates
-	  freq_channel(eNB2UE,UE->frame_parms.N_RB_DL,12*UE->frame_parms.N_RB_DL + 1);
-	  for(k=0; k<NUMBER_OF_eNB_MAX; k++) {
-	    for(aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
-	      for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-		for (i=0; i<frame_parms->N_RB_DL*12; i++) {
-		  ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[k][(aa<<1)+aarx])[2*i+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)(eNB2UE->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].x*AMP);
-		  ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[k][(aa<<1)+aarx])[2*i+1+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)(eNB2UE->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].y*AMP);
-		}
-	      }
-	    }
-	  }
-	}
-
-	if (l==6)
-          for (l2=2;l2<7;l2++)
-	    rx_pmch(UE,
-		    0,
-		    subframe%10,
-		    l2);
-	if (l==6)
-          for (l2=2;l2<7;l2++)
-	    rx_pmch(UE,
-		    0,
-		    subframe%10,
-		    l2);
-	if (l==11)
-          for (l2=7;l2<12;l2++)
-	    rx_pmch(UE,
-		    0,
-		    subframe%10,
-		    l2);
-      }
-
-      UE->dlsch_MCH[0]->harq_processes[0]->G = get_G(&UE->frame_parms,
-						     UE->dlsch_MCH[0]->harq_processes[0]->nb_rb,
-						     UE->dlsch_MCH[0]->harq_processes[0]->rb_alloc_even,
-						     get_Qm(UE->dlsch_MCH[0]->harq_processes[0]->mcs),
-						     1,2,
-						     UE->proc.proc_rxtx[0].frame_tx,subframe,0);
-      UE->dlsch_MCH[0]->harq_processes[0]->Qm = get_Qm(UE->dlsch_MCH[0]->harq_processes[0]->mcs);
-
-      dlsch_unscrambling(&UE->frame_parms,1,UE->dlsch_MCH[0],
-                         UE->dlsch_MCH[0]->harq_processes[0]->G,
-                         UE->pdsch_vars_MCH[0]->llr[0],0,subframe<<1);
-
-      ret = dlsch_decoding(UE,
-                           UE->pdsch_vars_MCH[0]->llr[0],
-                           &UE->frame_parms,
-                           UE->dlsch_MCH[0],
-                           UE->dlsch_MCH[0]->harq_processes[0],
-                           trials,
-                           subframe,
-                           0,0,0);
-
-      if (n_frames==1)
-        printf("MCH decoding returns %d\n",ret);
-
-      if (ret == (1+UE->dlsch_MCH[0]->max_turbo_iterations))
-        errs[0]++;
 
       UE->proc.proc_rxtx[0].frame_tx++;
       eNB->proc.proc_rxtx[0].frame_tx++;
+
     }
 
-    printf("errors %d/%d (Pe %e)\n",errs[round],trials,(double)errs[round]/trials);
+    printf("errors %d/%d (Pe %e)\n",UE->dlsch_mtch_errors[0][0],trials,(double)UE->dlsch_mtch_errors[0][0]/trials);
 
     if (awgn_flag==0)
       fprintf(fd,"SNR_%d_%d = [SNR_%d_%d %f]; errs_mch_%d_%d =[errs_mch_%d_%d  %d]; mch_trials_%d_%d =[mch_trials_%d_%d  %d];\n",
               mcs,N_RB_DL,mcs,N_RB_DL,SNR,
-              mcs,N_RB_DL,mcs,N_RB_DL,errs[0],
+              mcs,N_RB_DL,mcs,N_RB_DL,UE->dlsch_mtch_errors[0][0],
               mcs,N_RB_DL,mcs,N_RB_DL,trials);
     else
       fprintf(fd,"SNR_awgn_%d = [SNR_awgn_%d %f]; errs_mch_awgn_%d =[errs_mch_awgn_%d  %d]; mch_trials_awgn_%d =[mch_trials_awgn_%d %d];\n",
               N_RB_DL,N_RB_DL,SNR,
-              N_RB_DL,N_RB_DL,errs[0],
+              N_RB_DL,N_RB_DL,UE->dlsch_mtch_errors[0][0],
               N_RB_DL,N_RB_DL,trials);
 
     fflush(fd);
 
-    if (errs[0] == 0)
+    if (UE->dlsch_mtch_errors[0][0] == 0)
       break;
   }
 

openair2/RRC/LTE/rrc_UE.c

@@ -286,10 +286,21 @@ static void init_SI_UE( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_
   UE_rrc_inst[ctxt_pP->module_id].sib21[eNB_index] = malloc16_clear( sizeof(SystemInformationBlockType21_r14_t) );
 
 #endif
-  UE_rrc_inst[ctxt_pP->module_id].SI[eNB_index] = (uint8_t*)malloc16_clear( 64 );
+#ifdef Rel14
+  // FeMBMS structures
+  UE_rrc_inst[ctxt_pP->module_id].mib_mbms  = malloc16_clear( sizeof(MasterInformationBlock_MBMS_r14_t) );
+  UE_rrc_inst[ctxt_pP->module_id].sib1_mbms = malloc16_clear( sizeof(SystemInformationBlockType1_MBMS_r14_t) );
+  UE_rrc_inst[ctxt_pP->module_id].sib15     = malloc16_clear( sizeof(SystemInformationBlockType15_r11_t) );
+  UE_rrc_inst[ctxt_pP->module_id].sib16     = malloc16_clear( sizeof(SystemInformationBlockType16_r11_t) );
+#endif
 
+  UE_rrc_inst[ctxt_pP->module_id].SI[eNB_index] = (uint8_t*)malloc16_clear( 64 );
   UE_rrc_inst[ctxt_pP->module_id].si[eNB_index] = (SystemInformation_t*)malloc16_clear( sizeof(SystemInformation_t) );
 
+#ifdef Rel14
+  UE_rrc_inst[ctxt_pP->module_id].SI_mbms = (uint8_t*)malloc16_clear( 64 );
+  UE_rrc_inst[ctxt_pP->module_id].si_mbms = (SystemInformation_t*)malloc16_clear( sizeof(SystemInformation_MBMS_r14_t) );
+#endif
   UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus = 0;
   UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIcnt    = 0;
 }

openair2/RRC/LTE/rrc_defs.h

@@ -44,7 +44,7 @@
 #include "COMMON/platform_types.h"
 
 #include "LAYER2/MAC/mac.h"
-
+#include "MasterInformationBlock-MBMS-r14.h"
 //for D2D
 #define DEBUG_CTRL_SOCKET
 #define BUFSIZE                1024
@@ -172,6 +172,11 @@ void *send_UE_status_notification(void *);
 
 #include "SystemInformationBlockType1.h"
 #include "SystemInformation.h"
+#ifdef Rel14
+#include "MasterInformationBlock-MBMS-r14.h"
+#include "SystemInformation-MBMS-r14.h"
+#include "SystemInformationBlockType1-MBMS-r14.h"
+#endif
 #include "RRCConnectionReconfiguration.h"
 #include "RRCConnectionReconfigurationComplete.h"
 #include "RRCConnectionSetup.h"
@@ -782,6 +787,15 @@ typedef struct UE_RRC_INST_s {
   SystemInformationBlockType12_r9_t *sib12[NB_CNX_UE];
   SystemInformationBlockType13_r9_t *sib13[NB_CNX_UE];
 #endif
+#ifdef Rel14
+  uint8_t *SI_mbms;
+  // Maybe not needed, check parameters additionalNonMBSFNSubframes_r14
+  MasterInformationBlock_MBMS_r14_t *mib_mbms;
+  SystemInformationBlockType1_MBMS_r14_t *sib1_mbms;
+  SystemInformation_MBMS_r14_t *si_mbms; //!< Temporary storage for an SI message. Decoding happens in decode_SI().
+  SystemInformationBlockType15_r11_t *sib15;
+  SystemInformationBlockType16_r11_t *sib16;  
+#endif
 #ifdef CBA
   uint8_t                         num_active_cba_groups;
   uint16_t                        cba_rnti[NUM_MAX_CBA_GROUP];

targets/RT/USER/lte-ue.c

@@ -125,6 +125,10 @@ typedef struct band_info_s {
 
 band_info_t bands_to_scan;
 
+
+
+
+
 static const eutra_band_t eutra_bands[] = {
   { 1, 1920    * MHz, 1980    * MHz, 2110    * MHz, 2170    * MHz, FDD},
   { 2, 1850    * MHz, 1910    * MHz, 1930    * MHz, 1990    * MHz, FDD},
@@ -143,6 +147,7 @@ static const eutra_band_t eutra_bands[] = {
   {17,  704    * MHz,  716    * MHz,  734    * MHz,  746    * MHz, FDD},
   {20,  832    * MHz,  862    * MHz,  791    * MHz,  821    * MHz, FDD},
   {22, 3510    * MHz, 3590    * MHz, 3410    * MHz, 3490    * MHz, FDD},
+  {28,  703    * MHz, 748     * MHz,  758    * MHz,  803    * MHz, FDD},
   {33, 1900    * MHz, 1920    * MHz, 1900    * MHz, 1920    * MHz, TDD},
   {34, 2010    * MHz, 2025    * MHz, 2010    * MHz, 2025    * MHz, TDD},
   {35, 1850    * MHz, 1910    * MHz, 1850    * MHz, 1910    * MHz, TDD},
@@ -444,6 +449,9 @@ static void *UE_thread_synch(void *arg)
   static int UE_thread_synch_retval;
   int i ;
   PHY_VARS_UE *UE = (PHY_VARS_UE*) arg;
+  //IRTBL_start setting fembms hard coded to 2
+  UE->SF_count = 0; //counting subframes because we need the 40 ms frame-structure.
+  //IRTBL_end
   int current_band = 0;
   int current_offset = 0;
   sync_mode_t sync_mode = pbch;
@@ -468,6 +476,8 @@ static void *UE_thread_synch(void *arg)
   found = 0;
 
 
+
+
   if (UE->UE_scan == 0) {
     do  {
       current_band = eutra_bands[ind].band;
@@ -691,6 +701,7 @@ static void *UE_thread_synch(void *arg)
 	    return &UE_thread_synch_retval; // not reached
 	  }
 	}
+
 #if DISABLE_LOG_X
 	printf("[initial_sync] trying carrier off %d Hz, rxgain %d (DL %u, UL %u)\n",
 	       freq_offset,