Merge remote-tracking branch 'origin/develop-entv' into develop_integration_2019_w25

common/utils/LOG/vcd_signal_dumper.c

@@ -290,6 +290,8 @@ const char* eurecomFunctionsNames[] = {
   /* PHY signals  */
   "ue_synch",
   "ue_slot_fep",
+  "ue_slot_fep_mbsfn",
+  "ue_slot_fep_mbsfn_khz_1dot25",
   "ue_rrc_measurements",
   "ue_gain_control",
   "ue_adjust_synch",
@@ -356,9 +358,12 @@ const char* eurecomFunctionsNames[] = {
   "dlsch_decoding5",
   "dlsch_decoding6",
   "dlsch_decoding7",
+  "dlsch_pmch_decoding",
   "rx_pdcch",
   "dci_decoding",
   "rx_phich",
+  "rx_pmch",
+  "rx_pmch_khz_1dot25",
   "pdsch_procedures",
   "pdsch_procedures_si",
   "pdsch_procedures_p",

common/utils/LOG/vcd_signal_dumper.h

@@ -268,6 +268,8 @@ typedef enum {
   /* PHY signals  */
   VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SYNCH,
   VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP_MBSFN,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP_MBSFN_KHZ_1DOT25,
   VCD_SIGNAL_DUMPER_FUNCTIONS_UE_RRC_MEASUREMENTS,
   VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GAIN_CONTROL,
   VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH,
@@ -334,9 +336,12 @@ typedef enum {
   VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING5,
   VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING6,
   VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DECODING7,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_PMCH_DECODING,
   VCD_SIGNAL_DUMPER_FUNCTIONS_RX_PDCCH,
   VCD_SIGNAL_DUMPER_FUNCTIONS_DCI_DECODING,
   VCD_SIGNAL_DUMPER_FUNCTIONS_RX_PHICH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RX_PMCH,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RX_PMCH_KHZ_1DOT25,
   VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC,
   VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_SI,
   VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC_P,

common/utils/T/T_messages.txt

@@ -2138,6 +2138,16 @@ ID = VCD_FUNCTION_UE_SLOT_FEP
     GROUP = ALL:VCD:UE:VCD_FUNCTION
     FORMAT = int,value
     VCD_NAME = ue_slot_fep
+ID = VCD_FUNCTION_UE_SLOT_FEP_MBSFN
+    DESC = VCD function UE_SLOT_FEP_MBSFN
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = ue_slot_fep_mbsfn
+ID = VCD_FUNCTION_UE_SLOT_FEP_MBSFN_KHZ_1DOT25
+    DESC = VCD function UE_SLOT_FEP_MBSFN_KHZ_1DOT25
+    GROUP = ALL:VCD:UE:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = ue_slot_fep_mbsfn_khz_1dot25
 ID = VCD_FUNCTION_UE_RRC_MEASUREMENTS
     DESC = VCD function UE_RRC_MEASUREMENTS
     GROUP = ALL:VCD:UE:VCD_FUNCTION
@@ -2468,6 +2478,11 @@ ID = VCD_FUNCTION_DLSCH_DECODING7
     GROUP = ALL:VCD:ENB:VCD_FUNCTION
     FORMAT = int,value
     VCD_NAME = dlsch_decoding7
+ID = VCD_FUNCTION_DLSCH_PMCH_DECODING
+    DESC = VCD function DLSCH_PMCH_DECODING
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = dlsch_pmch_decoding
 ID = VCD_FUNCTION_RX_PDCCH
     DESC = VCD function RX_PDCCH
     GROUP = ALL:VCD:ENB:VCD_FUNCTION
@@ -2483,6 +2498,16 @@ ID = VCD_FUNCTION_RX_PHICH
     GROUP = ALL:VCD:ENB:VCD_FUNCTION
     FORMAT = int,value
     VCD_NAME = rx_phich
+ID = VCD_FUNCTION_RX_PMCH
+    DESC = VCD function RX_PMCH
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = rx_pmch
+ID = VCD_FUNCTION_RX_PMCH_KHZ_1DOT25
+    DESC = VCD function RX_PMCH_KHZ_1DOT25
+    GROUP = ALL:VCD:ENB:VCD_FUNCTION
+    FORMAT = int,value
+    VCD_NAME = rx_pmch_khz_1dot25
 ID = VCD_FUNCTION_PDSCH_PROC
     DESC = VCD function PDSCH_PROC
     GROUP = ALL:VCD:UE:VCD_FUNCTION

nfapi/open-nFAPI/nfapi/public_inc/nfapi_interface.h

@@ -702,6 +702,18 @@ typedef struct {
 #define NFAPI_PUCCH_CONFIG_N_AN_CS_TAG 0x003E
 #define NFAPI_PUCCH_CONFIG_N1_PUCCH_AN_TAG 0x003F
 
+typedef struct {
+       nfapi_uint8_tlv_t radioframe_allocation_period;
+       nfapi_uint8_tlv_t radioframe_allocation_offset;
+       nfapi_uint8_tlv_t non_mbsfn_config_flag;
+       nfapi_uint16_tlv_t non_mbsfn_subframeconfig;
+} nfapi_fembms_config_t;
+
+#define NFAPI_FEMBMS_CONFIG_RADIOFRAME_ALLOCATION_PERIOD_TAG 0x0042
+#define NFAPI_FEMBMS_CONFIG_RADIOFRAME_ALLOCATION_OFFSET_TAG 0x0043
+#define NFAPI_FEMBMS_CONFIG_NON_MBSFN_FLAG_TAG 0x0044
+#define NFAPI_FEMBMS_CONFIG_NON_MBSFN_SUBFRAMECONFIG_TAG 0x0045
+
 typedef struct {
 	nfapi_uint16_tlv_t bandwidth_configuration;
 	nfapi_uint16_tlv_t max_up_pts;
@@ -1097,6 +1109,7 @@ typedef struct {
 	nfapi_prach_config_t prach_config;
 	nfapi_pusch_config_t pusch_config;
 	nfapi_pucch_config_t pucch_config;
+	nfapi_fembms_config_t fembms_config;
 	nfapi_srs_config_t srs_config;
 	nfapi_uplink_reference_signal_config_t uplink_reference_signal_config;
 	nfapi_tdd_frame_structure_t tdd_frame_structure_config;
@@ -1118,6 +1131,7 @@ typedef struct {
 	nfapi_prach_config_t prach_config;
 	nfapi_pusch_config_t pusch_config;
 	nfapi_pucch_config_t pucch_config;
+        nfapi_fembms_config_t fembms_config;
 	nfapi_srs_config_t srs_config;
 	nfapi_uplink_reference_signal_config_t uplink_reference_signal_config;
 	nfapi_laa_config_t laa_config;

nfapi/open-nFAPI/nfapi/src/nfapi_p5.c

@@ -461,6 +461,12 @@ static uint8_t pack_param_response(void *msg, uint8_t **ppWritePackedMsg, uint8_
 			pack_tlv(NFAPI_PUCCH_CONFIG_N_AN_CS_TAG, &(pNfapiMsg->pucch_config.n_an_cs), ppWritePackedMsg, end, &pack_uint16_tlv_value) &&
 			pack_tlv(NFAPI_PUCCH_CONFIG_N1_PUCCH_AN_TAG, &(pNfapiMsg->pucch_config.n1_pucch_an), ppWritePackedMsg, end, &pack_uint16_tlv_value) &&
 
+                       pack_tlv(NFAPI_FEMBMS_CONFIG_RADIOFRAME_ALLOCATION_PERIOD_TAG, &(pNfapiMsg->fembms_config.radioframe_allocation_period), ppWritePackedMsg, end, &pack_uint8_tlv_value) &&
+                       pack_tlv(NFAPI_FEMBMS_CONFIG_RADIOFRAME_ALLOCATION_OFFSET_TAG, &(pNfapiMsg->fembms_config.radioframe_allocation_offset), ppWritePackedMsg, end, &pack_uint8_tlv_value) &&
+                       pack_tlv(NFAPI_FEMBMS_CONFIG_NON_MBSFN_FLAG_TAG, &(pNfapiMsg->fembms_config.non_mbsfn_config_flag), ppWritePackedMsg, end, &pack_uint8_tlv_value) &&
+                       pack_tlv(NFAPI_FEMBMS_CONFIG_NON_MBSFN_SUBFRAMECONFIG_TAG, &(pNfapiMsg->fembms_config.non_mbsfn_subframeconfig), ppWritePackedMsg, end, &pack_uint16_tlv_value) &&
+
+
 			pack_tlv(NFAPI_SRS_CONFIG_BANDWIDTH_CONFIGURATION_TAG, &(pNfapiMsg->srs_config.bandwidth_configuration), ppWritePackedMsg, end, &pack_uint16_tlv_value) &&
 			pack_tlv(NFAPI_SRS_CONFIG_MAX_UP_PTS_TAG, &(pNfapiMsg->srs_config.max_up_pts), ppWritePackedMsg, end, &pack_uint16_tlv_value) &&
 			pack_tlv(NFAPI_SRS_CONFIG_SRS_SUBFRAME_CONFIGURATION_TAG, &(pNfapiMsg->srs_config.srs_subframe_configuration), ppWritePackedMsg, end, &pack_uint16_tlv_value) &&

openair1/PHY/INIT/lte_init.c

@@ -310,6 +310,12 @@ void phy_config_request(PHY_Config_t *phy_config) {
 
   fp->num_MBSFN_config = 0;
 
+  fp->NonMBSFN_config_flag =cfg->fembms_config.non_mbsfn_config_flag.value;
+  fp->NonMBSFN_config.non_mbsfn_SubframeConfig = cfg->fembms_config.non_mbsfn_subframeconfig.value;
+  fp->NonMBSFN_config.radioframeAllocationPeriod = cfg->fembms_config.radioframe_allocation_period.value;
+  fp->NonMBSFN_config.radioframeAllocationOffset = cfg->fembms_config.radioframe_allocation_offset.value;
+  LOG_D(PHY,"eNB %d/%d frame NonMBSFN configured: %d (%x) %d/%d\n",Mod_id,CC_id,fp->NonMBSFN_config_flag,fp->NonMBSFN_config.non_mbsfn_SubframeConfig,fp->NonMBSFN_config.radioframeAllocationPeriod,fp->NonMBSFN_config.radioframeAllocationOffset);
+
   init_ncs_cell (fp, RC.eNB[Mod_id][CC_id]->ncs_cell);
 
 
@@ -335,6 +341,10 @@ void phy_config_sib13_eNB(module_id_t Mod_id,int CC_id,int mbsfn_Area_idx,
   }
 
   lte_gold_mbsfn (fp, RC.eNB[Mod_id][CC_id]->lte_gold_mbsfn_table, fp->Nid_cell_mbsfn);
+
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+  lte_gold_mbsfn_khz_1dot25 (fp, RC.eNB[Mod_id][CC_id]->lte_gold_mbsfn_khz_1dot25_table, fp->Nid_cell_mbsfn);
+#endif
 }
 
 

openair1/PHY/INIT/lte_init_ue.c

@@ -165,8 +165,29 @@ void phy_config_sib13_ue(module_id_t Mod_id,int CC_id,uint8_t eNB_id,int mbsfn_A
   }
 
   lte_gold_mbsfn(fp,PHY_vars_UE_g[Mod_id][CC_id]->lte_gold_mbsfn_table,fp->Nid_cell_mbsfn);
+
+  
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+  lte_gold_mbsfn_khz_1dot25(fp,PHY_vars_UE_g[Mod_id][CC_id]->lte_gold_mbsfn_khz_1dot25_table,fp->Nid_cell_mbsfn);
+#endif
+
 }
 
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+void phy_config_sib1_fembms_ue(module_id_t Mod_id,int CC_id,
+                        uint8_t eNB_id,
+                        struct LTE_NonMBSFN_SubframeConfig_r14 *nonMBSFN_SubframeConfig){
+  PHY_VARS_UE *ue        = PHY_vars_UE_g[Mod_id][CC_id];
+  LTE_DL_FRAME_PARMS *fp = &ue->frame_parms;
+  if (nonMBSFN_SubframeConfig != NULL) {
+    fp->NonMBSFN_config_flag = 0;
+    fp->NonMBSFN_config.radioframeAllocationPeriod=nonMBSFN_SubframeConfig->radioFrameAllocationPeriod_r14;
+    fp->NonMBSFN_config.radioframeAllocationOffset=nonMBSFN_SubframeConfig->radioFrameAllocationOffset_r14;
+    fp->NonMBSFN_config.non_mbsfn_SubframeConfig=(nonMBSFN_SubframeConfig->subframeAllocation_r14.buf[0]<<1 | nonMBSFN_SubframeConfig->subframeAllocation_r14.buf[0]>>7);
+  }
+}
+#endif
+
 
 /*
  * Configures UE MAC and PHY with radioResourceCommon received in mobilityControlInfo IE during Handover
@@ -872,4 +893,4 @@ void init_lte_ue_transport(PHY_VARS_UE *ue,int abstraction_flag) {
 
   ue->frame_parms.pucch_config_common.deltaPUCCH_Shift = 1;
   ue->dlsch_MCH[0]  = new_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_TURBO_ITERATIONS_MBSFN,ue->frame_parms.N_RB_DL,0);
-}
\ No newline at end of file
+}

openair1/PHY/INIT/lte_parms.c

@@ -125,6 +125,12 @@ int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf) {
       frame_parms->nb_prefix_samples0>>=(2-log2_osf);
       frame_parms->N_RBGS = 2;
       frame_parms->N_RBG = 13;
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+      frame_parms->ofdm_symbol_size_khz_1dot25     = 6144*osf;
+      frame_parms->first_carrier_offset_khz_1dot25 = frame_parms->ofdm_symbol_size_khz_1dot25 - 1800; //4344
+      frame_parms->nb_prefix_samples_khz_1dot25>>=(2-log2_osf);
+      frame_parms->nb_prefix_samples0_khz_1dot25>>=(2-log2_osf);
+#endif
       break;
 
     case 15:

openair1/PHY/INIT/phy_init.h

@@ -35,6 +35,9 @@
 #if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
 #include "LTE_SCellToAddMod-r10.h"
 #endif
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+#include "LTE_NonMBSFN-SubframeConfig-r14.h"
+#endif
 /** @addtogroup _PHY_STRUCTURES_
  * @{
  */
@@ -147,7 +150,6 @@ void phy_config_sib1_ue(module_id_t   Mod_id,
                         uint8_t          SIwindowsize,
                         uint16_t           SIperiod);
 
-
 /*!
   \fn void phy_config_sib2_ue(module_id_t Mod_id,uint8_t CC_id,uint8_t CH_index,
       RadioResourceConfigCommonSIB_t *radioResourceConfigCommon,
@@ -258,6 +260,10 @@ void phy_config_sib13_ue(module_id_t Mod_id,
                          int CC_id,uint8_t CH_index,int mbsfn_Area_idx,
                          long mbsfn_AreaId_r9);
 
+void phy_config_sib1_fembms_ue(module_id_t Mod_id,int CC_id,
+                        uint8_t eNB_id,
+			struct LTE_NonMBSFN_SubframeConfig_r14 *nonMBSFN_SubframeConfig);
+
 /**
 \brief Configure eNB MBSFN common parameters.
 \details Invoked upon transmission of SIB13 from eNB.

openair1/PHY/LTE_ESTIMATION/lte_dl_mbsfn_channel_estimation.c

@@ -19,11 +19,24 @@
  *      contact@openairinterface.org
  */
 
+/*! \file config_ue.c
+ * \brief This includes FeMBMS UE Channel Estimation Procedures for FeMBMS 1.25KHz Carrier Spacing 
+ * \author Javier Morgade
+ * \date 2019
+ * \version 0.1
+ * \email: javier.morgade@ieee.org
+ * @ingroup _phy
+
+ */
+
+
 #include <string.h>
 #include "PHY/defs_UE.h"
 #include "lte_estimation.h"
 #include "PHY/LTE_REFSIG/lte_refsig.h"
 
+#include "filt96_32_khz_1dot25.h"
+
 //#define DEBUG_CH
 int lte_dl_mbsfn_channel_estimation(PHY_VARS_UE *ue,
                                     module_id_t eNB_id,
@@ -769,3 +782,180 @@ int lte_dl_mbsfn_channel_estimation(PHY_VARS_UE *ue,
   return(0);
 }
 
+
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+int lte_dl_mbsfn_khz_1dot25_channel_estimation(PHY_VARS_UE *ue,
+                                    module_id_t eNB_id,
+                                    uint8_t eNB_offset,
+                                    int subframe)
+{
+
+
+
+  int pilot_khz_1dot25[600] __attribute__((aligned(16)));
+  unsigned char aarx/*,aa*/;
+  //unsigned int rb;
+  int16_t ch[2];
+  short *pil,*rxF,*dl_ch/*,*ch0,*ch1,*ch11,*chp,*ch_prev*/;
+  int ch_offset,symbol_offset;
+  int pilot_cnt;
+
+  int16_t *f,*f2,*fl,*f2l2,*fr,*f2r2/*,*f2_dc,*f_dc*/;
+
+  unsigned int k;
+
+  //  unsigned int n;
+  //  int i;
+
+  int **dl_ch_estimates=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[0];
+  int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF;
+
+  ch_offset     = 0;//(l*(ue->frame_parms.ofdm_symbol_size));
+  symbol_offset = 0;//ch_offset;//phy_vars_ue->lte_frame_parms.ofdm_symbol_size*l;
+
+  AssertFatal( ue->frame_parms.N_RB_DL==25,"OFDM symbol size %d not yet supported for FeMBMS\n",ue->frame_parms.N_RB_DL);
+
+  if( (subframe&0x1) == 0){
+        f=filt24_0_khz_1dot25;
+        f2=filt24_2_khz_1dot25;
+        fl=filt24_0_khz_1dot25;
+        f2l2=filt24_2_khz_1dot25;
+        fr=filt24_0r2_khz_1dot25;
+        f2r2=filt24_2r_khz_1dot25;
+        //f_dc=filt24_0_dcr_khz_1dot25;
+        //f2_dc=filt24_2_dcl_khz_1dot25;
+   }else{
+    	f=filt24_0_khz_1dot25;
+        f2=filt24_2_khz_1dot25;
+        fl=filt24_0_khz_1dot25;
+        f2l2=filt24_2_khz_1dot25;
+        fr=filt24_0r2_khz_1dot25;
+        f2r2=filt24_2r_khz_1dot25;
+        //f_dc=filt24_0_dcr_khz_1dot25;
+        //f2_dc=filt24_2_dcl_khz_1dot25;
+   }
+
+
+ for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
+    // generate pilot
+      lte_dl_mbsfn_khz_1dot25_rx(ue,
+                      &pilot_khz_1dot25[0],
+                      subframe);
+
+
+    pil   = (short *)&pilot_khz_1dot25[0];
+    rxF   = (short *)&rxdataF[aarx][((ue->frame_parms.first_carrier_offset_khz_1dot25))];
+    dl_ch = (short *)&dl_ch_estimates[aarx][ch_offset];
+
+    memset(dl_ch,0,4*(ue->frame_parms.ofdm_symbol_size_khz_1dot25));
+
+    if( (subframe&0x1) == 0){
+        rxF+=0;
+        k=0;
+    }else{
+        rxF+=6;//2*3;
+        k=3;
+    }
+
+    if(ue->frame_parms.N_RB_DL==25){ 
+       ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+       ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+       multadd_real_vector_complex_scalar(fl,
+                                ch,
+                                dl_ch,
+                                24);
+       pil+=2;    // Re Im
+       rxF+=12;
+       dl_ch+=8;
+
+       ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+       ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+       multadd_real_vector_complex_scalar(f2l2,
+                                ch,
+                                dl_ch,
+                                24);
+       pil+=2;    // Re Im
+       rxF+=12;
+       dl_ch+=16;
+
+       for(pilot_cnt=2;pilot_cnt<299;pilot_cnt+=2){
+
+               ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+               ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+               multadd_real_vector_complex_scalar(f,
+                                  ch,
+                                  dl_ch,
+                                  24);
+               pil+=2;    // Re Im
+               rxF+=12;
+               dl_ch+=8;
+
+               ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+               ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+               multadd_real_vector_complex_scalar(f2,
+                                  ch,
+                                  dl_ch,
+                                  24);
+               pil+=2;
+               rxF+=12;
+               dl_ch+=16;
+
+       }
+
+       rxF   = (int16_t *)&rxdataF[aarx][((symbol_offset+1+k))]; //Skip DC offset
+
+       for(pilot_cnt=0; pilot_cnt<297; pilot_cnt+=2){
+
+               ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+               ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+                
+               multadd_real_vector_complex_scalar(f,
+                                  ch,
+                                  dl_ch,
+                                  24);
+               pil+=2;
+               rxF+=12;
+               dl_ch+=8;
+
+               ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+               ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+       
+               multadd_real_vector_complex_scalar(f2,
+                                  ch,
+                                  dl_ch,
+                                  24);
+               pil+=2;
+               rxF+=12;
+               dl_ch+=16;
+       }
+
+       ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+       ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+       multadd_real_vector_complex_scalar(fr,
+                                 ch,
+                                 dl_ch,
+                                  24);
+       pil+=2;    // Re Im
+       rxF+=12;
+       dl_ch+=8;
+
+       ch[0] = (int16_t)(((int32_t)pil[0]*rxF[0] - (int32_t)pil[1]*rxF[1])>>15);
+       ch[1] = (int16_t)(((int32_t)pil[0]*rxF[1] + (int32_t)pil[1]*rxF[0])>>15);
+
+       multadd_real_vector_complex_scalar(f2r2,
+                                  ch,
+                                  dl_ch,
+                                  24);
+    }
+  }
+
+  return(0);
+}
+#endif
+
+

openair1/PHY/LTE_ESTIMATION/lte_estimation.h

@@ -141,6 +141,11 @@ int lte_dl_mbsfn_channel_estimation(PHY_VARS_UE *phy_vars_ue,
                                     int subframe,
                                     unsigned char l);
 
+int lte_dl_mbsfn_khz_1dot25_channel_estimation(PHY_VARS_UE *ue,
+                                    module_id_t eNB_id,
+                                    uint8_t eNB_offset,
+                                    int subframe);
+
 /*!
 \brief Frequency offset estimation for LTE
 We estimate the frequency offset by calculating the phase difference between channel estimates for symbols carrying pilots (l==0 or l==3/4). We take a moving average of the phase difference.

openair1/PHY/LTE_ESTIMATION/lte_sync_time.c

@@ -341,7 +341,6 @@ int lte_sync_time(int **rxdata, ///rx data in time domain
 {
 
 
-
   // perform a time domain correlation using the oversampled sync sequence
 
   unsigned int n, ar, s, peak_pos, peak_val, sync_source;

openair1/PHY/LTE_REFSIG/lte_dl_mbsfn.c

@@ -131,3 +131,92 @@ int lte_dl_mbsfn_rx(PHY_VARS_UE *ue,
   return(0);
 }
 
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+int lte_dl_mbsfn_khz_1dot25(PHY_VARS_eNB *eNB, int32_t *output,
+                 short amp,
+                 int subframe) 
+{
+
+  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_khz_1dot25;
+
+      mprime_dword     = mprime>>4;
+      mprime_qpsk_symb = mprime&0xf;
+
+      if (k >= eNB->frame_parms.ofdm_symbol_size_khz_1dot25) {
+        k++;  // skip DC carrier
+        k-=eNB->frame_parms.ofdm_symbol_size_khz_1dot25;
+      }
+      output[k] = qpsk[(eNB->lte_gold_mbsfn_khz_1dot25_table[subframe][mprime_dword]>>(2*mprime_qpsk_symb))&3];
+      mprime++;
+   }
+
+  return(0);
+}
+
+
+int lte_dl_mbsfn_khz_1dot25_rx(PHY_VARS_UE *ue,
+                    int *output,
+                    int subframe) 
+{
+
+  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
+    output[k] = qpsk[(ue->lte_gold_mbsfn_khz_1dot25_table[subframe][mprime_dword]>>(2*mprime_qpsk_symb))&3];
+
+    mprime++;
+    k++;
+
+  }
+
+  return(0);
+}
+
+#endif // MAKE Rel14
+

openair1/PHY/LTE_REFSIG/lte_gold_mbsfn.c

@@ -95,6 +95,34 @@ void lte_gold_mbsfn(LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_mbsfn_tabl
 }
 
 
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+void lte_gold_mbsfn_khz_1dot25(LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_mbsfn_khz_1dot25_table[10][150],uint16_t Nid_mbsfn){
+  unsigned char sfn;
+  unsigned int n,x1,x2;//,x1tmp,x2tmp;
+
+  for (sfn=0; sfn<10; sfn++) {
+    x2 = (Nid_mbsfn) + (((1+(Nid_mbsfn<<1))*(1 + (7*(1+sfn))))<<9); //cinit
+    x1 = 1+ (1<<31);
+    x2=x2 ^ ((x2 ^ (x2>>1) ^ (x2>>2) ^ (x2>>3))<<31);
+    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);
+    }
+    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_mbsfn_khz_1dot25_table[sfn][n] = x1^x2;
+    }
+  }
+}
+#endif
+
+
+
 #ifdef LTE_GOLD_MAIN
 main()
 {

openair1/PHY/LTE_REFSIG/lte_refsig.h

@@ -57,6 +57,8 @@ void lte_gold_ue_spec_port5(uint32_t lte_gold_uespec_port5_table[20][38],uint16_
 
 void lte_gold_mbsfn(LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_mbsfn_table[10][3][42],uint16_t Nid_MBSFN);
 
+void lte_gold_mbsfn_khz_1dot25 (LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_mbsfn_1khz_1dot25_table[10][150],uint16_t Nid_MBSFN);
+
 
 /*! \brief This function generates the cell-specific reference signal sequence (36-211, Sec 6.10.1.1)
 @param phy_vars_eNB Pointer to eNB variables
@@ -144,6 +146,10 @@ int lte_dl_mbsfn_rx(PHY_VARS_UE *phy_vars_ue,
                     int subframe,
                     unsigned char l);
 
+int lte_dl_mbsfn_khz_1dot25_rx(PHY_VARS_UE *ue,
+                    int *output,
+                    int subframe);
+
 
 
 

openair1/PHY/LTE_TRANSPORT/lte_mcs.c

@@ -349,6 +349,43 @@ int get_G(LTE_DL_FRAME_PARMS *frame_parms,uint16_t nb_rb,uint32_t *rb_alloc,uint
   }
 }
 
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+int get_G_khz_1dot25(LTE_DL_FRAME_PARMS *frame_parms,uint16_t nb_rb,uint32_t *rb_alloc,uint8_t mod_order,uint8_t Nl,uint8_t num_pdcch_symbols,int frame,uint8_t subframe,uint8_t beamforming_mode)
+{
+  //int G_adj;
+
+  /*if (is_pmch_subframe(frame,subframe,frame_parms) == 0) {
+    G_adj= adjust_G(frame_parms,rb_alloc,mod_order,subframe);
+
+    //printf("get_G subframe %d mod_order %d, nb_rb %d: rb_alloc %x,%x,%x,%x, G_adj %d\n",subframe,mod_order,nb_rb,rb_alloc[3],rb_alloc[2],rb_alloc[1],rb_alloc[0], G_adj);
+    if (frame_parms->Ncp==NORMAL) { // normal prefix
+      // PDDDPDD PDDDPDD - 13 PDSCH symbols, 10 full, 3 w/ pilots = 10*12 + 3*8
+      // PCDDPDD PDDDPDD - 12 PDSCH symbols, 9 full, 3 w/ pilots = 9*12 + 3*8
+      // PCCDPDD PDDDPDD - 11 PDSCH symbols, 8 full, 3 w/pilots = 8*12 + 3*8
+      if (beamforming_mode==0 && frame_parms->nb_antenna_ports_eNB!=1) 
+        return((((int)nb_rb * mod_order * ((11-num_pdcch_symbols)*12 + 3*8)) - G_adj)*Nl);
+      else if(beamforming_mode==7)
+        return(((int)nb_rb * mod_order * ((7-num_pdcch_symbols)*12 + 3*10 + 4*9)) - G_adj);
+      else //SISO
+        return(((int)nb_rb * mod_order * ((11-num_pdcch_symbols)*12 + 3*10)) - G_adj);
+    } else {
+      // PDDPDD PDDPDD - 11 PDSCH symbols, 8 full, 3 w/ pilots = 8*12 + 3*8
+      // PCDPDD PDDPDD - 10 PDSCH symbols, 7 full, 3 w/ pilots = 7*12 + 3*8
+      // PCCPDD PDDPDD - 9 PDSCH symbols, 6 full, 3 w/pilots = 6*12 + 3*8
+      if (frame_parms->nb_antenna_ports_eNB!=1)
+        return((((int)nb_rb * mod_order * ((9-num_pdcch_symbols)*12 + 3*8)) - G_adj)*Nl);
+      else if(beamforming_mode==7)
+        return(((int)nb_rb * mod_order * ((5-num_pdcch_symbols)*12 + 3*8 + 4*9)) - G_adj);
+      else //SISO
+        return(((int)nb_rb * mod_order * ((9-num_pdcch_symbols)*12 + 3*10)) - G_adj);
+    }
+  } else { // This is an MBSFN subframe
+    return((int)frame_parms->N_RB_DL * mod_order * 102);
+  }*/
+  return((int)frame_parms->N_RB_DL * mod_order * 120);
+}
+#endif
+
 // following function requires dlsch_tbs_full.h
 #include "PHY/LTE_TRANSPORT/dlsch_tbs_full.h"
 

openair1/PHY/LTE_TRANSPORT/phich_common.c

@@ -33,7 +33,13 @@
 #include "PHY/defs_eNB.h"
 
 
-uint8_t get_mi(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe) {
+uint8_t get_mi(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe)
+{
+  // for FeMBMS
+  if(frame_parms->FeMBMS_active!=0){
+	return(0);
+  }
+
   // for FDD
   if (frame_parms->frame_type == FDD)
     return 1;

openair1/PHY/LTE_TRANSPORT/pmch_common.c

@@ -22,6 +22,88 @@
 #include "PHY/defs_eNB.h"
 #include "PHY/phy_extern.h"