Merge branch 'develop-nb-iot-mac' into develop-nb-iot

Conflicts:
	openair1/PHY/LTE_TRANSPORT/dlsch_coding_NB_IoT.c
	openair1/PHY/LTE_TRANSPORT/dlsch_modulation_NB_IoT.c
	openair1/PHY/LTE_TRANSPORT/dlsch_scrambling_NB_IoT.c
	openair1/PHY/LTE_TRANSPORT/npbch_NB_IoT.c
	openair1/PHY/LTE_TRANSPORT/proto.h

cmake_targets/CMakeLists.txt

@@ -311,7 +311,7 @@ if (NOT ${ret} STREQUAL 0)
 endif (NOT ${ret} STREQUAL 0)
 file(GLOB rrc_source ${RRC_FULL_DIR}/*.c)
 set(rrc_source  ${rrc_source} ${OPENAIR2_DIR}/RRC/LITE/MESSAGES/asn1_msg.c)
-set(rrc_source  ${rrc_source} ${OPENAIR2_DIR}/RRC/LITE/MESSAGES/asn1_msg_nb_iot.c)
+set(rrc_source  ${rrc_source} ${OPENAIR2_DIR}/RRC/LITE/MESSAGES/asn1_msg_NB_IoT.c)
 file(GLOB rrc_h ${RRC_FULL_DIR}/*.h)
 set(rrc_h ${rrc_h} ${RRC_FULL_DIR}/asn1_constants.h)
 set_source_files_properties(${rrc_source} PROPERTIES COMPILE_FLAGS -w) # suppress warnings from generated code
@@ -567,6 +567,12 @@ add_boolean_option(MESSAGE_CHART_GENERATOR_PHY     False "trace some PHY exchang
 
 add_boolean_option(FLEXRAN_AGENT_SB_IF             False         "enable FlexRAN agent to inteface with a SDN controller")
 
+################################################################
+# NB-IOT
+################################################################
+add_boolean_option(NB_IOT True "Enabling NB-IoT code")
+
+
 ########################
 # Include order
 ##########################
@@ -959,12 +965,15 @@ add_library(SECU_CN ${SECU_CN_SRC})
 ################################"
 set(SCHED_SRC
   ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_eNb.c
-  ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_eNb_nb_iot.c
+  ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_eNb_NB_IoT.c
   ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_ue.c
   ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_common.c
+  ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_common_NB_IoT.c
   ${OPENAIR1_DIR}/SCHED/phy_mac_stub.c
+  ${OPENAIR1_DIR}/SCHED/IF_Module_L1_primitives_NB_IoT.c
   ${OPENAIR1_DIR}/SCHED/pucch_pc.c
   ${OPENAIR1_DIR}/SCHED/pusch_pc.c
+  ${OPENAIR1_DIR}/SCHED/pusch_pc_NB_IoT.c
   ${OPENAIR1_DIR}/SCHED/srs_pc.c
 )
 add_library(SCHED_LIB ${SCHED_SRC})
@@ -976,34 +985,50 @@ set(PHY_SRC
   ${RRC_FULL_DIR}/asn1_constants.h
   # actual source
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pss.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/npss_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/sss.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/nsss_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pilots.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pilots_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pilots_mbsfn.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dlsch_coding.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dlsch_coding_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dlsch_modulation.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dlsch_modulation_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dlsch_demodulation.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dlsch_llr_computation.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/power_control.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dlsch_decoding.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dlsch_scrambling.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dlsch_scrambling_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dci_tools.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dci_tools_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/uci_tools.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/uci_tools_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/lte_mcs.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/lte_mcs_NB_IoT.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/lte_Isc_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pbch.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/npbch_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dci.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dci_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/phich.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pcfich.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pucch.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/prach.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/nprach_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pmch.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pch.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/group_hopping.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/group_hopping_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/srs_modulation.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/drs_modulation.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/ulsch_modulation.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/ulsch_demodulation.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/ulsch_demodulation_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/ulsch_coding.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/ulsch_decoding.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/ulsch_decoding_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/rar_tools.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/print_stats.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/initial_sync.c
@@ -1017,37 +1042,48 @@ set(PHY_SRC
   ${OPENAIR1_DIR}/PHY/MODULATION/beamforming.c
   ${OPENAIR1_DIR}/PHY/MODULATION/compute_bf_weights.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/freq_equalization.c
+  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/freq_equalization_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_sync_time.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_sync_timefreq.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_adjust_sync.c
+  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_adjust_sync_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_dl_channel_estimation.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_dl_bf_channel_estimation.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_dl_mbsfn_channel_estimation.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_ul_channel_estimation.c
+  ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_ul_channel_estimation_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_est_freq_offset.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_ue_measurements.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/lte_eNB_measurements.c
   ${OPENAIR1_DIR}/PHY/LTE_ESTIMATION/adjust_gain.c
   ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_dl_cell_spec.c
+  ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_dl_cell_spec_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_dl_uespec.c   
   ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_gold.c   
+  ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_gold_NB_IoT.c   
   ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_gold_mbsfn.c
   ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_dl_mbsfn.c
   ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_ul_ref.c
+  ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_ul_ref_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/CODING/lte_segmentation.c
+  ${OPENAIR1_DIR}/PHY/CODING/lte_segmentation_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte.c
+  ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte_lte.c
   ${OPENAIR1_DIR}/PHY/CODING/3gpplte_sse.c
   ${OPENAIR1_DIR}/PHY/CODING/crc_byte.c
+  ${OPENAIR1_DIR}/PHY/CODING/crc_byte_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/CODING/3gpplte_turbo_decoder_sse_8bit.c
   ${OPENAIR1_DIR}/PHY/CODING/3gpplte_turbo_decoder_sse_16bit.c
   ${OPENAIR1_DIR}/PHY/CODING/3gpplte_turbo_decoder_avx2_16bit.c
   ${OPENAIR1_DIR}/PHY/CODING/lte_rate_matching.c
+  ${OPENAIR1_DIR}/PHY/CODING/lte_rate_matching_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/CODING/rate_matching.c
   ${OPENAIR1_DIR}/PHY/CODING/viterbi.c
   ${OPENAIR1_DIR}/PHY/CODING/viterbi_lte.c
+  ${OPENAIR1_DIR}/PHY/CODING/viterbi_lte_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/INIT/lte_init.c
-  ${OPENAIR1_DIR}/PHY/INIT/lte_init_nb_iot.c
+  ${OPENAIR1_DIR}/PHY/INIT/lte_init_NB_IoT.c
   ${OPENAIR1_DIR}/PHY/INIT/lte_parms.c
   ${OPENAIR1_DIR}/PHY/INIT/lte_param_init.c
   ${OPENAIR1_DIR}/PHY/TOOLS/file_output.c
@@ -1077,12 +1113,15 @@ add_library(PHY ${PHY_SRC})
 #####################
 set(MAC_DIR ${OPENAIR2_DIR}/LAYER2/MAC)
 set(RLC_DIR ${OPENAIR2_DIR}/LAYER2/RLC)
+set(PHY_INTERFACE_DIR ${OPENAIR2_DIR}/PHY_INTERFACE)
 set(RLC_UM_DIR ${OPENAIR2_DIR}/LAYER2/RLC/UM_v9.3.0)
 set(RLC_AM_DIR ${OPENAIR2_DIR}/LAYER2/RLC/AM_v9.3.0)
 set(RLC_TM_DIR ${OPENAIR2_DIR}/LAYER2/RLC/TM_v9.3.0)
 set(RRC_DIR ${OPENAIR2_DIR}/RRC/LITE)
 set(PDCP_DIR  ${OPENAIR2_DIR}/LAYER2/PDCP_v10.1.0)
 set(L2_SRC
+  ${PHY_INTERFACE_DIR}/IF_Module_NB_IoT.c
+  ${PHY_INTERFACE_DIR}/IF_Module_L2_primitives_NB_IoT.c
   ${OPENAIR2_DIR}/LAYER2/openair2_proc.c
   ${PDCP_DIR}/pdcp.c
   ${PDCP_DIR}/pdcp_fifo.c
@@ -1118,38 +1157,42 @@ set(L2_SRC
   ${RLC_DIR}/rlc.c
   ${RLC_DIR}/rlc_rrc.c
   ${RLC_DIR}/rlc_mpls.c
-  ${RRC_DIR}/vars_nb_iot.c
   ${RRC_DIR}/rrc_UE.c
   ${RRC_DIR}/rrc_eNB.c
-  ${RRC_DIR}/rrc_eNB_nb_iot.c
+  ${RRC_DIR}/rrc_eNB_NB_IoT.c
   ${RRC_DIR}/rrc_eNB_S1AP.c
   ${RRC_DIR}/rrc_eNB_UE_context.c
+  ${RRC_DIR}/rrc_eNB_UE_context_NB_IoT.c
   ${RRC_DIR}/rrc_common.c
-  ${RRC_DIR}/rrc_common_nb_iot.c
+  ${RRC_DIR}/rrc_common_NB_IoT.c
   ${RRC_DIR}/L2_interface.c
-  ${RRC_DIR}/L2_interface_nb_iot.c
+  ${RRC_DIR}/L2_interface_NB_IoT.c
   )
 set (MAC_SRC
   ${MAC_DIR}/lte_transport_init.c
   ${MAC_DIR}/main.c
-  ${MAC_DIR}/IF_Module_nb_iot.c
+  ${MAC_DIR}/main_NB_IoT.c
   ${MAC_DIR}/ue_procedures.c
   ${MAC_DIR}/ra_procedures.c
   ${MAC_DIR}/l1_helpers.c
   ${MAC_DIR}/rar_tools.c
   ${MAC_DIR}/eNB_scheduler.c
+  ${MAC_DIR}/eNB_scheduler_NB_IoT.c
   ${MAC_DIR}/eNB_scheduler_dlsch.c
-  ${MAC_DIR}/eNB_scheduler_dlsch_nb_iot.c
+  ${MAC_DIR}/eNB_scheduler_dlsch_NB_IoT.c
   ${MAC_DIR}/eNB_scheduler_ulsch.c
-  ${MAC_DIR}/eNB_scheduler_ulsch_nb_iot.c
+  ${MAC_DIR}/eNB_scheduler_ulsch_NB_IoT.c
   ${MAC_DIR}/eNB_scheduler_mch.c
   ${MAC_DIR}/eNB_scheduler_bch.c
+  ${MAC_DIR}/eNB_scheduler_bch_NB_IoT.c
   ${MAC_DIR}/eNB_scheduler_primitives.c
-  ${MAC_DIR}/eNB_scheduler_primitives_nb_iot.c
+  ${MAC_DIR}/output_handler_NB_IoT.c
   ${MAC_DIR}/eNB_scheduler_RA.c
-  ${MAC_DIR}/eNB_scheduler_RA_nb_iot.c
+  ${MAC_DIR}/eNB_scheduler_RA_NB_IoT.c
   ${MAC_DIR}/pre_processor.c
   ${MAC_DIR}/config.c
+  ${MAC_DIR}/config_NB_IoT.c
+  ${MAC_DIR}/schedule_tool_NB_IoT.c
  )
 
 if (FLEXRAN_AGENT_SB_IF)

cmake_targets/oaisim_noS1_build_oai/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8)
+
+set (  ADDR_CONF False )
+set (  DEBUG_OMG False )
+set (  DISABLE_XER_PRINT False )
+set (  DRIVER2013 True )
+set (  EMOS False )
+set (  ENABLE_FXP True )
+set (  ENABLE_ITTI True )
+set (  ENABLE_NAS_UE_LOGGING False )
+set (  ENABLE_NEW_MULTICAST True )
+set (  ENABLE_PGM_TRANSPORT True )
+set (  ENABLE_RAL False )
+set (  ENABLE_SECURITY False )
+set (  ENABLE_STANDALONE_EPC False)
+set (  ENABLE_USE_CPU_EXECUTION_TIME True )
+set (  ENABLE_USE_MME False )
+set (  ENABLE_USE_RAW_SOCKET_FOR_SGI False)
+set (  ENABLE_VCD_FIFO False )
+set (  ENB_MODE True )
+set (  EXMIMO_IOT True )
+set (  HARD_RT False )
+set (  JUMBO_FRAME True )
+set (  LARGE_SCALE False )
+set (  LINK_ENB_PDCP_TO_GTPV1U False)
+set (  LINUX_LIST False )
+set (  LINUX True )
+set (  LOCALIZATION False )
+set (  LOG_NO_THREAD 1 )
+set (  DEADLINE_SCHEDULER False )
+set (  MAC_CONTEXT 1 )
+set (  MAX_NUM_CCs 1 )
+set (  MESSAGE_CHART_GENERATOR         False )
+set (  MESSAGE_CHART_GENERATOR_RLC_MAC False )
+set (  MESSAGE_CHART_GENERATOR_PHY     False )
+set (  MIH_C_MEDIEVAL_EXTENSIONS False )
+set (  MSG_PRINT False )
+set (  MU_RECEIVER False )
+set (  NAS_ADDRESS_FIX True )
+set (  NAS_BUILT_IN_UE False)
+set (  NAS_MME False )
+set (  NAS_UE False )
+set (  NB_ANTENNAS_RX "2" )
+set (  NB_ANTENNAS_TX "2" )
+set (  NB_ANTENNAS_TXRX "2" )
+set (  NEW_FFT True )
+set (  NO_RRM True )
+set (  OAI_EMU True )
+set (  OAISIM True )
+set (  OAI_NW_DRIVER_TYPE_ETHERNET False )
+set (  OAI_NW_DRIVER_USE_NETLINK True )
+set (  OPENAIR1 True )
+set (  OPENAIR2 True )
+set (  OPENAIR_EMU False )
+set (  OPENAIR_LTE True )
+set (  PACKAGE_NAME "oaisim" )
+set (  PBS_SIM False )
+set (  PDCP_USE_NETLINK True )
+set (  PC_DSP True )
+set (  PC_TARGET True )
+set (  PDCP_MSG_PRINT False )
+set (  PERFECT_CE False )
+set (  PHY_ABSTRACTION True )
+set (  PHY_CONTEXT False )
+set (  PHY_EMUL False )
+set (  PHYSIM True )
+set (  PUCCH True )
+set (  RANDOM_BF False )
+set (  RF_BOARD "False" )
+set (  RRC_ASN1_VERSION "Rel10" )
+set (  RLC_STOP_ON_LOST_PDU False )
+set (  RRC_MSG_PRINT False )
+set (  RTAI False )
+set (  SECU False )
+set (  SMBV False )
+set (  SPECTRA False )
+set (  TEST_OMG False )
+set (  USE_3GPP_ADDR_AS_LINK_ADDR False )
+set (  USE_MME "R10" )
+set (  USER_MODE True )
+set (  XER_PRINT False )
+set (  DEBUG_PHY False )
+set (  DEBUG_PHY_PROC False)
+set (  DEBUG_DLSCH False)
+set ( CMAKE_BUILD_TYPE  )
+set ( CFLAGS_PROCESSOR_USER "" )
+set ( XFORMS True )
+set ( PRINT_STATS True )
+set ( RRC_ASN1_VERSION "Rel14")
+set ( ENABLE_VCD_FIFO False )
+set ( T_TRACER False )
+include(${CMAKE_CURRENT_SOURCE_DIR}/../CMakeLists.txt)

openair1/PHY/CODING/ccoding_byte_NB_IoT.c

@@ -12,12 +12,10 @@
 * \warning
 */
 
-#include "defs.h"
-
-#include "defs_NB_IoT.h"
+#include "PHY/CODING/defs_NB_IoT.h"
 
 unsigned char  ccodelte_table_NB_IoT[128];      // for transmitter
-//unsigned char  ccodelte_table_rev[128];  // for receiver
+unsigned short glte_NB_IoT[] = { 0133, 0171, 0165 }; // {A,B} //renaimed but is exactly the same as the one in the old implementation
 
 /*************************************************************************
   Encodes for an arbitrary convolutional code of rate 1/3
@@ -44,12 +42,15 @@ void ccode_encode_NB_IoT (int32_t numbits,
   state = 0;
 
   if (add_crc == 2) {
-    crc = crc16(inPtr,numbits);     // crc is 2 bytes
+
+      crc = crc16_NB_IoT(inPtr,numbits);     // crc is 2 bytes
       // scramble with RNTI
       crc ^= (((uint32_t)rnti)<<16);  // XOR with crc
       first_bit = 2;
       c = (uint8_t)((crc>>16)&0xff);
+
   } else {
+
       next_last_byte = numbits>>3;
       first_bit      = (numbits-6)&7;
       c = inPtr[next_last_byte-1];
@@ -59,6 +60,7 @@ void ccode_encode_NB_IoT (int32_t numbits,
   // get bits from last byte of input (or crc)
   
   for (shiftbit = 0 ; shiftbit <(8-first_bit) ; shiftbit++) {
+
       if ((c&(1<<(7-first_bit-shiftbit))) != 0)
           state |= (1<<shiftbit);
   }
@@ -71,6 +73,7 @@ void ccode_encode_NB_IoT (int32_t numbits,
     c = *inPtr++;
 
     for (shiftbit = 7; (shiftbit>=0) && (numbits>0); shiftbit--,numbits--) {
+
         state >>= 1;
 
         if ((c&(1<<shiftbit)) != 0) {
@@ -82,9 +85,7 @@ void ccode_encode_NB_IoT (int32_t numbits,
         *outPtr++ = out  & 1;
         *outPtr++ = (out>>1)&1;
         *outPtr++ = (out>>2)&1;
-
     }
-
   }
   
   // now code 16-bit CRC for DCI 						// Tail-biting is applied to CRC bits , input 16 bits , output 48 bits
@@ -93,6 +94,7 @@ void ccode_encode_NB_IoT (int32_t numbits,
     c16 = (uint16_t)(crc>>16);
 	
     for (shiftbit = 15; (shiftbit>=0); shiftbit--) {
+
         state >>= 1;
 
         if ((c16&(1<<shiftbit)) != 0) {
@@ -104,7 +106,6 @@ void ccode_encode_NB_IoT (int32_t numbits,
         *outPtr++ = out  & 1;
         *outPtr++ = (out>>1)&1;
         *outPtr++ = (out>>2)&1;  
-
     }
   }
 }
@@ -121,6 +122,7 @@ void ccodelte_init_NB_IoT(void)
   unsigned int  i, j, k, sum;
 
   for (i = 0; i < 128; i++) {
+
     ccodelte_table_NB_IoT[i] = 0;
 
     /* Compute 3 output bits */
@@ -128,7 +130,7 @@ void ccodelte_init_NB_IoT(void)
       sum = 0;
 
       for (k = 0; k < 7; k++)
-        if ((i & glte[j]) & (1 << k))
+        if ((i & glte_NB_IoT[j]) & (1 << k))
           sum++;
 
       /* Write the sum modulo 2 in bit j */

openair1/PHY/CODING/crc_byte_NB_IoT.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/* file: crc_byte.c
+   purpose: generate 3GPP LTE CRCs. Byte-oriented implementation of CRC's
+   author: raymond.knopp@eurecom.fr, matthieu.kanj@b-com.com
+   date: 07/2017
+
+*/
+
+
+#ifndef USER_MODE
+#define __NO_VERSION__
+
+#endif
+
+//#include "PHY/types.h"
+
+//#include "defs.h"   // to delete in final code version
+
+#include "PHY/CODING/defs_NB_IoT.h"  //
+/*ref 36-212 v8.6.0 , pp 8-9 */
+/* the highest degree is set by default */
+unsigned int     poly24a_NB_IoT = 0x864cfb00;   //1000 0110 0100 1100 1111 1011  D^24 + D^23 + D^18 + D^17 + D^14 + D^11 + D^10 + D^7 + D^6 + D^5 + D^4 + D^3 + D + 1
+unsigned int     poly24b_NB_IoT = 0x80006300;    // 1000 0000 0000 0000 0110 0011  D^24 + D^23 + D^6 + D^5 + D + 1
+unsigned int     poly16_NB_IoT = 0x10210000;    // 0001 0000 0010 0001            D^16 + D^12 + D^5 + 1
+unsigned int     poly12_NB_IoT = 0x80F00000;    // 1000 0000 1111                 D^12 + D^11 + D^3 + D^2 + D + 1
+unsigned int     poly8_NB_IoT = 0x9B000000;     // 1001 1011                      D^8  + D^7  + D^4 + D^3 + D + 1
+/*********************************************************
+
+For initialization && verification purposes,
+   bit by bit implementation with any polynomial
+
+The first bit is in the MSB of each byte
+
+*********************************************************/
+unsigned int crcbit_NB_IoT (unsigned char * inputptr, int octetlen, unsigned int poly)
+{
+  unsigned int i, crc = 0, c;
+
+  while (octetlen-- > 0) {
+      
+      c = (*inputptr++) << 24;
+
+      for (i = 8; i != 0; i--) {
+
+          if ((1 << 31) & (c ^ crc))
+
+              crc = (crc << 1) ^ poly;
+
+          else
+        
+              crc <<= 1;
+
+          c <<= 1;
+      }
+  }
+
+  return crc;
+}
+
+/*********************************************************
+
+crc table initialization
+
+*********************************************************/
+static unsigned int        crc24aTable_NB_IoT[256];
+static unsigned int        crc24bTable_NB_IoT[256];
+static unsigned short      crc16Table_NB_IoT[256];
+static unsigned short      crc12Table_NB_IoT[256];
+static unsigned char       crc8Table_NB_IoT[256];
+
+void crcTableInit_NB_IoT (void)
+{
+  unsigned char c = 0;
+
+  do {
+       crc24aTable_NB_IoT[c] = crcbit_NB_IoT (&c, 1, poly24a_NB_IoT);
+       crc24bTable_NB_IoT[c] = crcbit_NB_IoT (&c, 1, poly24b_NB_IoT);
+       crc16Table_NB_IoT[c] = (unsigned short) (crcbit_NB_IoT (&c, 1, poly16_NB_IoT) >> 16);
+       crc12Table_NB_IoT[c] = (unsigned short) (crcbit_NB_IoT (&c, 1, poly12_NB_IoT) >> 16);
+       crc8Table_NB_IoT[c] = (unsigned char) (crcbit_NB_IoT (&c, 1, poly8_NB_IoT) >> 24);
+  } while (++c);
+
+}
+/*********************************************************
+
+Byte by byte implementations,
+assuming initial byte is 0 padded (in MSB) if necessary
+
+*********************************************************/
+unsigned int crc24a_NB_IoT (unsigned char * inptr, int bitlen)
+{
+
+  int            octetlen, resbit;
+  unsigned int   crc = 0;
+  
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+    
+      crc = (crc << 8) ^ crc24aTable_NB_IoT[(*inptr++) ^ (crc >> 24)];
+
+  }
+
+  if (resbit > 0)
+
+      crc = (crc << resbit) ^ crc24aTable_NB_IoT[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
+
+  return crc;
+}
+
+unsigned int crc24b_NB_IoT (unsigned char * inptr, int bitlen)
+{
+
+  int             octetlen, resbit;
+  unsigned int    crc = 0;
+  
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+
+      crc = (crc << 8) ^ crc24bTable_NB_IoT[(*inptr++) ^ (crc >> 24)];
+
+  }
+
+  if (resbit > 0)
+
+      crc = (crc << resbit) ^ crc24bTable_NB_IoT[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
+
+  return crc;
+}
+
+unsigned int crc16_NB_IoT (unsigned char * inptr, int bitlen)
+{
+  int             octetlen, resbit;
+  unsigned int    crc = 0;
+  
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+
+    crc = (crc << 8) ^ (crc16Table_NB_IoT[(*inptr++) ^ (crc >> 24)] << 16);
+
+  }
+
+  if (resbit > 0)
+
+    crc = (crc << resbit) ^ (crc16Table_NB_IoT[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))] << 16);
+
+  return crc;
+}
+
+unsigned int crc8_NB_IoT (unsigned char * inptr, int bitlen)
+{
+  int             octetlen, resbit;
+  unsigned int             crc = 0;
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+    crc = crc8Table_NB_IoT[(*inptr++) ^ (crc >> 24)] << 24;
+  }
+
+  if (resbit > 0)
+    crc = (crc << resbit) ^ (crc8Table_NB_IoT[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))] << 24);
+
+  return crc;
+}
+
+
+//#ifdef DEBUG_CRC
+/*******************************************************************/
+/**
+   Test code
+********************************************************************/
+
+// #include <stdio.h>
+
+// main()
+// {
+//   unsigned char test[] = "Thebigredfox";
+//   crcTableInit();
+//   printf("%x\n", crcbit(test, sizeof(test) - 1, poly24));
+//   printf("%x\n", crc24(test, (sizeof(test) - 1)*8));
+//   printf("%x\n", crcbit(test, sizeof(test) - 1, poly8));
+//   printf("%x\n", crc8(test, (sizeof(test) - 1)*8));
+// }
+//#endif
+

openair1/PHY/CODING/lte_rate_matching_NB_IoT.c

@@ -12,16 +12,20 @@
 * \warning
 */
 
+/* // check if this ifdef MAIN is required for NB-IoT
 #ifdef MAIN
 #include <stdio.h>
 #include <stdlib.h>
 #endif
-#include "PHY/defs.h"
-#include "assertions.h"
+*/
 
+//#include "PHY/CODING/defs_NB_IoT.h"
 #include "PHY/defs_NB_IoT.h"
+//#include "assertions.h"
+
+//#include "PHY/LTE_REFSIG/defs_NB_IoT.h"   // does this file is needed ?
 
-static uint32_t bitrev_cc[32] = {1,17,9,25,5,21,13,29,3,19,11,27,7,23,15,31,0,16,8,24,4,20,12,28,2,18,10,26,6,22,14,30};
+static uint32_t bitrev_cc_NB_IoT[32] = {1,17,9,25,5,21,13,29,3,19,11,27,7,23,15,31,0,16,8,24,4,20,12,28,2,18,10,26,6,22,14,30};
 
 uint32_t sub_block_interleaving_cc_NB_IoT(uint32_t D, uint8_t *d,uint8_t *w)
 {
@@ -39,10 +43,11 @@ uint32_t sub_block_interleaving_cc_NB_IoT(uint32_t D, uint8_t *d,uint8_t *w)
 
     for (col=0; col<32; col++) {
 
-    index = bitrev_cc[col];
+      index = bitrev_cc_NB_IoT[col];
       index3 = 3*index;
 
         for (row=0; row<RCC; row++) {
+
           w[k]          =   d[(int32_t)index3-(int32_t)ND3];
           w[Kpi+k]      =   d[(int32_t)index3-(int32_t)ND3+1];
           w[(Kpi<<1)+k] =   d[(int32_t)index3-(int32_t)ND3+2];
@@ -62,12 +67,11 @@ uint32_t lte_rate_matching_cc_NB_IoT(uint32_t RCC,      // RRC = 2
 				                             uint8_t   *e)	     // length 1600
 {
   uint32_t ind=0,k;
-
   uint16_t Kw = 3*(RCC<<5);   				  // 3*64 = 192
 
   for (k=0; k<E; k++) {
 
-    while(w[ind] == LTE_NULL) {
+    while(w[ind] == LTE_NULL_NB_IoT) {
 
       ind++;
 
@@ -84,3 +88,136 @@ uint32_t lte_rate_matching_cc_NB_IoT(uint32_t RCC,      // RRC = 2
 
   return(E);
 }
+
+//******************* below functions related to uplink transmission , to be reviwed *********
+// this function should be adapted to NB-IoT , this deinterleaving is for LTE
+void sub_block_deinterleaving_cc_NB_IoT(uint32_t D,int8_t *d,int8_t *w)
+{
+
+  //WANG_Hao uint32_t RCC = (D>>5), ND, ND3;
+  uint32_t RCC = (D>>5);
+  ptrdiff_t   ND, ND3;
+  uint32_t row,col,Kpi,index;
+  //WANG_Hao uint32_t index3,k;
+  ptrdiff_t index3;
+  uint32_t k;
+
+  if ((D&0x1f) > 0)
+    RCC++;
+
+  Kpi = (RCC<<5);
+  //  Kpi3 = Kpi*3;
+  ND = Kpi - D;
+
+  ND3 = ND*3;
+
+  k=0;
+
+  for (col=0; col<32; col++) {
+
+    index = bitrev_cc_NB_IoT[col];
+    index3 = 3*index;
+
+    for (row=0; row<RCC; row++) {
+
+      d[index3-ND3]   = w[k];
+      d[index3-ND3+1] = w[Kpi+k];
+      d[index3-ND3+2] = w[(Kpi<<1)+k];
+
+      index3+=96;
+      index+=32;
+      k++;
+    }
+  }
+
+}
+
+
+
+void lte_rate_matching_cc_rx_NB_IoT(uint32_t RCC,
+                                    uint16_t E,
+                                    int8_t *w,
+                                    uint8_t *dummy_w,
+                                    int8_t *soft_input)
+{
+
+
+
+  uint32_t ind=0,k;
+  uint16_t Kw = 3*(RCC<<5);
+  uint32_t acc=1;
+  int16_t w16[Kw];
+
+  memset(w,0,Kw);
+  memset(w16,0,Kw*sizeof(int16_t));
+
+  for (k=0; k<E; k++) {
+
+
+    while(dummy_w[ind] == LTE_NULL_NB_IoT) {
+
+      ind++;
+
+      if (ind==Kw)
+        ind=0;
+    }
+
+ 
+    w16[ind] += soft_input[k];
+
+    ind++;
+
+    if (ind==Kw) {
+      ind=0;
+      acc++;
+    }
+  }
+
+  // rescale
+  for (ind=0; ind<Kw; ind++) {
+    //    w16[ind]=(w16[ind]/acc);
+    if (w16[ind]>7)
+      w[ind]=7;
+    else if (w16[ind]<-8)
+      w[ind]=-8;
+    else
+      w[ind]=(int8_t)w16[ind];
+  }
+
+}
+
+
+uint32_t generate_dummy_w_cc_NB_IoT(uint32_t D, uint8_t *w)
+{
+
+  uint32_t RCC = (D>>5), ND;
+  uint32_t col,Kpi,index;
+  int32_t k;
+
+  if ((D&0x1f) > 0)
+    RCC++;
+
+  Kpi = (RCC<<5);
+  //  Kpi3 = Kpi*3;
+  ND = Kpi - D;
+
+  // copy d02 to dD2 (for mod Kpi operation from clause (4), p.16 of 36.212
+  k=0;
+
+  for (col=0; col<32; col++) {
+
+    index = bitrev_cc_NB_IoT[col];
+
+    if (index<ND) {
+      w[k]          = LTE_NULL_NB_IoT;
+      w[Kpi+k]      = LTE_NULL_NB_IoT;
+      w[(Kpi<<1)+k] = LTE_NULL_NB_IoT;
+
+    }
+
+
+    k+=RCC;
+  }
+
+  return(RCC);
+}

openair1/PHY/CODING/lte_segmentation_NB_IoT.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/* file: lte_segmentation.c
+   purpose: Procedures for transport block segmentation for LTE (turbo-coded transport channels)
+   author: raymond.knopp@eurecom.fr
+   date: 21.10.2009
+*/
+#include "PHY/defs_NB_IoT.h"
+#include "SCHED/extern_NB_IoT.h"
+
+//#define DEBUG_SEGMENTATION
+
+int lte_segmentation_NB_IoT(unsigned char *input_buffer,
+                            unsigned char **output_buffers,
+                            unsigned int B,
+                            unsigned int *C,
+                            unsigned int *Cplus,
+                            unsigned int *Cminus,
+                            unsigned int *Kplus,
+                            unsigned int *Kminus,
+                            unsigned int *F)
+{
+
+  unsigned int L,Bprime,Bprime_by_C,r,Kr,k,s,crc;
+
+  if (B<=6144) {
+    L=0;
+    *C=1;
+    Bprime=B;
+  } else {
+    L=24;
+    *C = B/(6144-L);
+
+    if ((6144-L)*(*C) < B)
+      *C=*C+1;
+
+    Bprime = B+((*C)*L);
+  }
+
+  if ((*C)>MAX_NUM_DLSCH_SEGMENTS_NB_IoT) {
+      LOG_E(PHY,"lte_segmentation.c: too many segments %d, B %d, L %d, Bprime %d\n",*C,B,L,Bprime);
+    return(-1);
+  }
+
+  // Find K+
+  Bprime_by_C  = Bprime/(*C);
+
+  if (Bprime_by_C <= 40) {
+    *Kplus = 40;
+    *Kminus = 0;
+  } else if (Bprime_by_C<=512) { // increase by 1 byte til here
+    *Kplus = (Bprime_by_C>>3)<<3;
+    *Kminus = Bprime_by_C-8;
+  } else if (Bprime_by_C <=1024) { // increase by 2 bytes til here
+    *Kplus = (Bprime_by_C>>4)<<4;
+
+    if (*Kplus < Bprime_by_C)
+      *Kplus = *Kplus + 16;
+
+    *Kminus = (*Kplus - 16);
+  } else if (Bprime_by_C <= 2048) { // increase by 4 bytes til here
+    *Kplus = (Bprime_by_C>>5)<<5;
+
+    if (*Kplus < Bprime_by_C)
+      *Kplus = *Kplus + 32;
+
+    *Kminus = (*Kplus - 32);
+  } else if (Bprime_by_C <=6144 ) { // increase by 8 bytes til here
+
+    *Kplus = (Bprime_by_C>>6)<<6;
+
+
+    if (*Kplus < Bprime_by_C)
+      *Kplus = *Kplus + 64;
+
+    *Kminus = (*Kplus - 64);
+  } else {
+    msg("lte_segmentation.c: Illegal codeword size !!!\n");
+    return(-1);
+  }
+
+  if (*C == 1) {
+    *Cplus = *C;
+    *Kminus = 0;
+    *Cminus = 0;
+  } else {
+
+    //    printf("More than one segment (%d), exiting \n",*C);
+    //    exit(-1);
+    *Cminus = ((*C)*(*Kplus) - (Bprime))/((*Kplus) - (*Kminus));
+    *Cplus  = (*C) - (*Cminus);
+  }
+
+  *F = ((*Cplus)*(*Kplus) + (*Cminus)*(*Kminus) - (Bprime));
+
+  if ((input_buffer) && (output_buffers)) {
+
+    for (k=0; k<*F>>3; k++) {
+      output_buffers[0][k] = 0;
+    }
+
+    s=0;
+
+    for (r=0; r<*C; r++) {
+
+      if (r<*Cminus)
+        Kr = *Kminus;
+      else
+        Kr = *Kplus;
+
+      while (k<((Kr - L)>>3)) {
+        output_buffers[r][k] = input_buffer[s];
+	//	printf("encoding segment %d : byte %d (%d) => %d\n",r,k,Kr>>3,input_buffer[s]);
+        k++;
+        s++;
+      }
+
+      if (*C > 1) { // add CRC
+        crc = crc24b_NB_IoT(output_buffers[r],Kr-24)>>8;
+        output_buffers[r][(Kr-24)>>3] = ((uint8_t*)&crc)[2];
+        output_buffers[r][1+((Kr-24)>>3)] = ((uint8_t*)&crc)[1];
+        output_buffers[r][2+((Kr-24)>>3)] = ((uint8_t*)&crc)[0];
+
+      }
+
+      k=0;
+    }
+  }
+
+  return(0);
+}
+
+

openair1/PHY/INIT/defs_NB_IoT.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+
+#ifndef __INIT_DEFS_NB_IOT__H__
+#define __INIT_DEFS_NB_IOT__H__
+
+//#include "PHY/defs_NB_IoT.h"
+#include "openair2/PHY_INTERFACE/IF_Module_NB_IoT.h"  
+// nfapi_interface.h is required here, it is called through IF_Module_NB_IoT.h
+
+//#include "SystemInformationBlockType2.h"
+//#include "RadioResourceConfigCommonSIB.h"
+//#include "RadioResourceConfigDedicated.h"
+//#include "TDD-Config.h"
+//#include "MBSFN-SubframeConfigList.h"
+//#include "MobilityControlInfo.h"
+//#if defined(Rel10) || defined(Rel14)
+//#include "SCellToAddMod-r10.h"
+//#endif
+
+/*brief Configure LTE_DL_FRAME_PARMS with components derived after initial synchronization (MIB-NB decoding + primary/secondary synch).*/
+void phy_config_mib_eNB_NB_IoT(int  		Mod_id,
+						   	   int      	CC_id,
+						   	   int          eutra_band,
+						       int          Nid_cell,
+						       int          Ncp,
+						       int			Ncp_UL,
+						       int          p_eNB,
+						       uint16_t		EARFCN,
+						       uint16_t		prb_index, // NB_IoT_RB_ID,
+						       uint16_t 	operating_mode,
+						       uint16_t		control_region_size,
+						       uint16_t		eutra_NumCRS_ports);
+
+/*NB_phy_config_sib1_eNB is not needed since NB-IoT use only FDD mode*/
+
+/*brief Configure LTE_DL_FRAME_PARMS with components of SIB2-NB (at eNB).*/
+
+//void NB_phy_config_sib2_eNB(module_id_t                            Mod_id,
+//                         int                                		CC_id,
+//                         RadioResourceConfigCommonSIB_NB_r13_t      *radioResourceConfigCommon
+//                         );
+
+void phy_config_sib2_eNB_NB_IoT(uint8_t Mod_id,
+                         		int CC_id,
+                         		nfapi_config_NB_IoT_t *config,
+						 		nfapi_rf_config_t *rf_config,
+								nfapi_uplink_reference_signal_config_t* ul_nrs_config,
+								extra_phyConfig_t* extra_phy_parms);
+
+void phy_config_dedicated_eNB_NB_IoT(module_id_t Mod_id,
+                              	 	 int CC_id,
+                              	 	 rnti_t rnti,
+							     	 extra_phyConfig_t* extra_phy_parms); 
+
+// void phy_init_lte_top_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms); 
+
+
+
+#endif
+

openair1/PHY/INIT/lte_init.c

@@ -32,76 +32,13 @@
 #define DEBUG_PHY
 #include "assertions.h"
 #include <math.h>
+#include "PHY/LTE_REFSIG/defs.h"
 
 extern uint16_t prach_root_sequence_map0_3[838];
 extern uint16_t prach_root_sequence_map4[138];
 uint8_t dmrs1_tab[8] = {0,2,3,4,6,8,9,10};
 
-#if defined(NB_IoT)
 
-void NB_phy_config_mib_eNB(int                 Mod_id,
-			int                 CC_id,
-			int                 eutra_band,
-			int                 Nid_cell,
-			int                 Ncp,
-			int                 p_eNB,
-			uint32_t            dl_CarrierFreq,
-			uint32_t            ul_CarrierFreq) {
-
-  
-  LTE_DL_FRAME_PARMS *fp;
-
-  LOG_I(PHY,"Configuring MIB for instance %d, CCid %d : (band %d,N_RB_DL %d,Nid_cell %d,p %d,DL freq %u)\n",
-	Mod_id, CC_id, eutra_band, N_RB_DL_array[dl_Bandwidth], Nid_cell, p_eNB,dl_CarrierFreq);
-
-  /*if (RC.eNB == NULL) {
-    RC.eNB                               = (PHY_VARS_eNB ***)malloc((1+NUMBER_OF_eNB_MAX)*sizeof(PHY_VARS_eNB***));
-    LOG_I(PHY,"RC.eNB = %p\n",RC.eNB);
-    memset(RC.eNB,0,(1+NUMBER_OF_eNB_MAX)*sizeof(PHY_VARS_eNB***));
-  }
-  if (RC.eNB[Mod_id] == NULL) {
-    RC.eNB[Mod_id]                       = (PHY_VARS_eNB **)malloc((1+MAX_NUM_CCs)*sizeof(PHY_VARS_eNB**));
-    LOG_I(PHY,"RC.eNB[%d] = %p\n",Mod_id,RC.eNB[Mod_id]);
-    memset(RC.eNB[Mod_id],0,(1+MAX_NUM_CCs)*sizeof(PHY_VARS_eNB***));
-  }
-  if (RC.eNB[Mod_id][CC_id] == NULL) {
-    RC.eNB[Mod_id][CC_id] = (PHY_VARS_eNB *)malloc(sizeof(PHY_VARS_eNB));
-    LOG_I(PHY,"RC.eNB[%d][%d] = %p\n",Mod_id,CC_id,RC.eNB[Mod_id][CC_id]);
-    RC.eNB[Mod_id][CC_id]->Mod_id        = Mod_id;
-    RC.eNB[Mod_id][CC_id]->CC_id         = CC_id;
-  }
-
-  RC.eNB[Mod_id][CC_id]->mac_enabled     = 1;
-
-  fp = &RC.eNB[Mod_id][CC_id]->frame_parms; */
-
-  fp->Nid_cell                           = Nid_cell;
-  fp->nushift                            = Nid_cell%6;
-  fp->eutra_band                         = eutra_band;
-  fp->Ncp                                = Ncp;
-  fp->nb_antenna_ports_eNB               = p_eNB;
-  fp->dl_CarrierFreq                     = dl_CarrierFreq;
-  fp->ul_CarrierFreq                     = ul_CarrierFreq;
-  
-
-  init_frame_parms(fp,1);
-  init_lte_top(fp);
-
-}
-
-void NB_phy_config_sib2_eNB(uint8_t Mod_id,
-                         int CC_id,
-                         RadioResourceConfigCommonSIB_t *radioResourceConfigCommon,
-                         ARFCN_ValueEUTRA_t *ul_CArrierFreq,
-                         AdditionalSpectrumEmission_t *additionalSpectrumEmission,
-                         )
-{
-
-}
-
-#endif
-
-// FIXME not used anywhere
 void phy_config_mib(LTE_DL_FRAME_PARMS *fp,
                     uint8_t N_RB_DL,
                     uint8_t Nid_cell,

openair1/PHY/LTE_ESTIMATION/defs_NB_IoT.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#ifndef __LTE_ESTIMATION_DEFS_NB_IOT__H__
+#define __LTE_ESTIMATION_DEFS_NB_IOT__H__
+
+#include "PHY/defs_NB_IoT.h"
+
+/*
+int lte_est_timing_advance(NB_IoT_DL_FRAME_PARMS *frame_parms,
+                           NB_IoT_eNB_SRS *lte_eNb_srs,
+                           unsigned int *eNb_id,
+                           unsigned char clear,
+                           unsigned char number_of_cards,
+                           short coef);
+*/
+
+int NB_IoT_est_timing_advance_pusch(PHY_VARS_eNB_NB_IoT* phy_vars_eNB,module_id_t UE_id);
+
+
+
+int lte_ul_channel_estimation_NB_IoT(PHY_VARS_eNB_NB_IoT      *phy_vars_eNB,
+			      					 eNB_rxtx_proc_NB_IoT_t   *proc,
+                              		 module_id_t              eNB_id,
+                              		 module_id_t              UE_id,
+                              		 uint8_t                  l,
+                              		 uint8_t                  Ns,
+                              		 uint8_t                  cooperation_flag);
+
+int16_t lte_ul_freq_offset_estimation_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms,
+                                      		 int32_t *ul_ch_estimates,
+                                      		 uint16_t nb_rb);
+
+void freq_equalization_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms,
+                       		  int **rxdataF_comp,
+                       		  int **ul_ch_mag,
+                       		  int **ul_ch_mag_b,
+                       		  unsigned char symbol,
+                       	      unsigned short Msc_RS,
+                              unsigned char Qm);
+
+/** @} */
+#endif

openair1/PHY/LTE_ESTIMATION/lte_adjust_sync_NB_IoT.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+//#include "PHY/types.h"
+#include "PHY/defs_NB_IoT.h"
+//#include "PHY/extern.h"
+
+//#include "UTIL/LOG/vcd_signal_dumper.h"
+
+#define DEBUG_PHY
+
+int NB_IoT_est_timing_advance_pusch(PHY_VARS_eNB_NB_IoT* eNB,uint8_t UE_id)
+{
+  static int first_run=1;
+  static int max_pos_fil2=0;
+  int temp, i, aa, max_pos=0, max_val=0;
+  short Re,Im,coef=24576;
+  short ncoef = 32768 - coef;
+
+  NB_IoT_DL_FRAME_PARMS *frame_parms = &eNB->frame_parms;
+  NB_IoT_eNB_PUSCH *eNB_pusch_vars = eNB->pusch_vars[UE_id];
+  int32_t **ul_ch_estimates_time=  eNB_pusch_vars->drs_ch_estimates_time[0];
+  uint8_t cyclic_shift = 0;
+  int sync_pos = (frame_parms->ofdm_symbol_size-cyclic_shift*frame_parms->ofdm_symbol_size/12)%(frame_parms->ofdm_symbol_size);
+
+
+  for (i = 0; i < frame_parms->ofdm_symbol_size; i++) {
+    temp = 0;
+
+    for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
+      Re = ((int16_t*)ul_ch_estimates_time[aa])[(i<<1)];
+      Im = ((int16_t*)ul_ch_estimates_time[aa])[1+(i<<1)];
+      temp += (Re*Re/2) + (Im*Im/2);
+    }
+
+    if (temp > max_val) {
+      max_pos = i;
+      max_val = temp;
+    }
+  }
+
+  if (max_pos>frame_parms->ofdm_symbol_size/2)
+    max_pos = max_pos-frame_parms->ofdm_symbol_size;
+
+  // filter position to reduce jitter
+  if (first_run == 1) {
+    first_run=0;
+    max_pos_fil2 = max_pos;
+  } else
+    max_pos_fil2 = ((max_pos_fil2 * coef) + (max_pos * ncoef)) >> 15;
+
+#ifdef DEBUG_PHY
+  LOG_D(PHY,"frame %d: max_pos = %d, max_pos_fil = %d, sync_pos=%d\n",eNB->proc.frame_rx,max_pos,max_pos_fil2,sync_pos);
+#endif //DEBUG_PHY
+
+  return(max_pos_fil2-sync_pos);
+}

openair1/PHY/LTE_REFSIG/defs_NB_IoT.h

@@ -16,7 +16,7 @@
 
 #ifndef __LTE_REFSIG_DEFS_NB_IOT__H__
 #define __LTE_REFSIG_DEFS_NB_IOT__H__
-#include "PHY/defs.h"
+
 #include "PHY/defs_NB_IoT.h"
 
 /** @ingroup _PHY_REF_SIG
@@ -27,7 +27,9 @@
 @param lte_gold_table pointer to table where sequences are stored
 @param Nid_cell Cell Id for NB_IoT (to compute sequences for local and adjacent cells) */
 
-void lte_gold_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_table[20][2][14],uint16_t Nid_cell);
+void lte_gold_NB_IoT(NB_IoT_DL_FRAME_PARMS  *frame_parms,
+					 uint32_t 				lte_gold_table_NB_IoT[20][2][14],
+					 uint16_t 				Nid_cell);
 
 /*! \brief This function generates the Narrowband reference signal (NRS) sequence (36-211, Sec 6.10.1.1)
 @param phy_vars_eNB Pointer to eNB variables
@@ -38,12 +40,21 @@ void lte_gold_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_table[20]
 @param p antenna index
 @param RB_IoT_ID the ID of the RB dedicated for NB_IoT
 */
-int lte_dl_cell_spec_NB_IoT(PHY_VARS_eNB *phy_vars_eNB,
+int lte_dl_cell_spec_NB_IoT(PHY_VARS_eNB_NB_IoT  *phy_vars_eNB,
                      		int32_t 			 *output,
                      		short 				 amp,
                      		unsigned char 		 Ns,
                      		unsigned char 		 l,
-                     unsigned char p
+                     		unsigned char 		 p,
 					 		unsigned short 		 RB_IoT_ID); 
 
+
+unsigned int lte_gold_generic_NB_IoT(unsigned int  *x1,
+									 unsigned int  *x2,
+									 unsigned char reset);
+		
+void generate_ul_ref_sigs_rx_NB_IoT(void);
+
+void free_ul_ref_sigs_NB_IoT(void);
+			 
 #endif

openair1/PHY/LTE_REFSIG/lte_dl_cell_spec_NB_IoT.c

@@ -12,18 +12,16 @@
 * \warning
 */
 
+/* check if this is required for NB-IoT
 #ifdef USER_MODE
 #include <stdio.h>
 #include <stdlib.h>
 #endif
-
-#include "defs.h"
-#include "PHY/defs.h"
-
-#include "defs_NB_IoT.h"
+*/
+#include "PHY/LTE_REFSIG/defs_NB_IoT.h"
 #include "PHY/defs_NB_IoT.h"
 
-int lte_dl_cell_spec_NB_IoT(PHY_VARS_eNB *phy_vars_eNB,
+int lte_dl_cell_spec_NB_IoT(PHY_VARS_eNB_NB_IoT   *phy_vars_eNB,
                             int32_t               *output,
                             short                 amp,
                             unsigned char         Ns,
@@ -31,12 +29,12 @@ int lte_dl_cell_spec_NB_IoT(PHY_VARS_eNB *phy_vars_eNB,
                             unsigned char         p,
 					                  unsigned short        RB_IoT_ID) 			// the ID of the RB dedicated for NB_IoT
 {
-  unsigned char nu,mprime,mprime_dword,mprime_qpsk_symb,m;
+  unsigned char   nu,m;
   unsigned short  k,a;
   unsigned short  NB_IoT_start,bandwidth_even_odd;
   int32_t         qpsk[4];
 
-  a = (amp*ONE_OVER_SQRT2_Q15)>>15;
+  a = (amp*ONE_OVER_SQRT2_Q15_NB_IoT)>>15;
   ((short *)&qpsk[0])[0] = a;
   ((short *)&qpsk[0])[1] = a;
   ((short *)&qpsk[1])[0] = -a;
@@ -55,21 +53,22 @@ int lte_dl_cell_spec_NB_IoT(PHY_VARS_eNB *phy_vars_eNB,
   else if ((p==1) && (l>0))
     nu = 0;
   else {
-    printf("lte_dl_cell_spec: p %d, l %d -> ERROR\n",p,l);
+    printf("lte_dl_cell_spec_NB_IoT: p %d, l %d -> ERROR\n",p,l);
     return(-1);
   }
 
   // testing if the total number of RBs is even or odd 
-  bandwidth_even_odd = frame_parms->N_RB_DL % 2;    // 0 even, 1 odd
+  bandwidth_even_odd = phy_vars_eNB->frame_parms.N_RB_DL % 2;    // 0 even, 1 odd
   
-  mprime = 0; 										// mprime = 0,1 for NB_IoT //  for LTE , maximum number of resources blocks (110) - the total number of RB in the selected bandwidth (.... 15 , 25 , 50, 100)
-  k = (nu + phy_vars_eNB->lte_frame_parms.nushift)%6;
+  //mprime = 0; 										// mprime = 0,1 for NB_IoT //  for LTE , maximum number of resources blocks (110) - the total number of RB in the selected bandwidth (.... 15 , 25 , 50, 100)
+  k = (nu + phy_vars_eNB->frame_parms.nushift)%6;
 
-  if(RB_IoT_ID < (phy_vars_eNB->lte_frame_parms.N_RB_DL/2))
-  {
-		NB_IoT_start = phy_vars_eNB->lte_frame_parms.ofdm_symbol_size - 12*(phy_vars_eNB->lte_frame_parms.N_RB_DL/2) - (bandwidth_even_odd*6) + 12*(RB_IoT_ID%(ceil(phy_vars_eNB->lte_frame_parms.N_RB_DL/(float)2)));
+  if(RB_IoT_ID < (phy_vars_eNB->frame_parms.N_RB_DL/2))
+  {																																//XXX this mod operation is not valid since the second member is not an integer but double (for the moment i put a cast)
+		NB_IoT_start = phy_vars_eNB->frame_parms.ofdm_symbol_size - 12*(phy_vars_eNB->frame_parms.N_RB_DL/2) - (bandwidth_even_odd*6) + 12*(RB_IoT_ID%((int)(ceil(phy_vars_eNB->frame_parms.N_RB_DL/(float)2))));
   } else {
-		NB_IoT_start = (bandwidth_even_odd*6) + 12*(RB_IoT_ID%(ceil(phy_vars_eNB->lte_frame_parms.N_RB_DL/(float)2)));
+	  	  	  	  	  	  	  	  	  	  	  	  	 //XXX invalid mod operation (put a cast for the moment)
+		NB_IoT_start = (bandwidth_even_odd*6) + 12*(RB_IoT_ID%((int)(ceil(phy_vars_eNB->frame_parms.N_RB_DL/(float)2))));
   }
    
   k+=NB_IoT_start;
@@ -78,7 +77,7 @@ int lte_dl_cell_spec_NB_IoT(PHY_VARS_eNB *phy_vars_eNB,
   DevAssert( l < 2 );
 
   for (m=0; m<2; m++) {
-    output[k] = qpsk[(phy_vars_eNB->lte_gold_table_NB_IoT[Ns][l][0]) & 3];
+    output[k] = qpsk[(phy_vars_eNB->lte_gold_table_NB_IoT[Ns][l][0]) & 3]; //TODO should be defined one for NB-IoT
     k+=6;
   }
 

openair1/PHY/LTE_REFSIG/lte_gold_NB_IoT.c

@@ -12,10 +12,10 @@
 * \warning
 */
 
-#include "defs.h"
-#include "defs_NB_IoT.h"
+//#include "defs.h"
+#include "PHY/LTE_REFSIG/defs_NB_IoT.h"
 
-void lte_gold_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_table_NB_IoT[20][2][14],uint16_t Nid_cell)  //  Nid_cell = Nid_cell_NB_IoT
+void lte_gold_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_table_NB_IoT[20][2][14],uint16_t Nid_cell)  //  Nid_cell = Nid_cell_NB_IoT
 {
   unsigned char ns,l,Ncp=1;
   unsigned int  n,x1,x2;
@@ -24,9 +24,7 @@ void lte_gold_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms,uint32_t lte_gold_table_NB_
 
     for (l=0; l<2; l++) {
 
-      x2 = Ncp +
-           (Nid_cell<<1) +
-		   (((1+(Nid_cell<<1))*(1 + (l+5) + (7*(1+ns))))<<10); //cinit
+      x2 = Ncp + (Nid_cell<<1) + (((1+(Nid_cell<<1))*(1 + (l+5) + (7*(1+ns))))<<10); //cinit
      
       x1 = 1+ (1<<31);
       x2 = x2 ^ ((x2 ^ (x2>>1) ^ (x2>>2) ^ (x2>>3))<<31);

openair1/PHY/LTE_TRANSPORT/dci.c

@@ -2120,6 +2120,8 @@ uint8_t generate_dci_top(uint8_t num_ue_spec_dci,
   // generate DCIs in order of decreasing aggregation level, then common/ue spec
   // MAC is assumed to have ordered the UE spec DCI according to the RNTI-based randomization
   for (L=3; L>=0; L--) {
+
+	  //first common DCI
     for (i=0; i<num_common_dci; i++) {
 
       if (dci_alloc[i].L == (uint8_t)L) {
@@ -2140,6 +2142,7 @@ uint8_t generate_dci_top(uint8_t num_ue_spec_dci,
       }
     }
 
+    //start the second loop from the end of the previous one for ue specific DCI
     for (; i<num_ue_spec_dci + num_common_dci; i++) {
 
       if (dci_alloc[i].L == (uint8_t)L) {
@@ -2368,7 +2371,6 @@ uint8_t generate_dci_top(uint8_t num_ue_spec_dci,
 
   return(num_pdcch_symbols);
 }
-
 #ifdef PHY_ABSTRACTION
 uint8_t generate_dci_top_emul(PHY_VARS_eNB *phy_vars_eNB,
                               uint8_t num_ue_spec_dci,

openair1/PHY/LTE_TRANSPORT/dci_nb_iot.h → openair1/PHY/LTE_TRANSPORT/dci_NB_IoT.h

@@ -29,21 +29,25 @@
 * \note
 * \warning
 */
-#ifndef USER_MODE
-#include "PHY/types.h"
-#else
+#ifndef __DCI_NB_IOT_H__
+#define __DCI_NB_IOT_H__
+
+//#ifndef USER_MODE
+//#include "PHY/types.h"
+//#else
 #include <stdint.h>
-#endif
+//#endif
 
-typedef enum DCI_format_NB
+typedef enum 
 {
   DCIFormatN0 = 0,
   DCIFormatN1,
-  DCIFormatN1_RA,
+  DCIFormatN1_RA,//is for initial RA procedure (semi-static information) so maybe is not needed
   DCIFormatN1_RAR,
+  DCIFormatN2,
   DCIFormatN2_Ind,
   DCIFormatN2_Pag,
-}e_DCI_format_NB;
+}DCI_format_NB_IoT_t;
 
 ///  DCI Format Type 0 (180 kHz, 23 bits)
 struct DCIFormatN0{
@@ -68,7 +72,6 @@ struct DCIFormatN0{
 };
 
 typedef struct DCIFormatN0 DCIFormatN0_t;
-#define sizeof_DDCIFormatN0_t 23
 
 ///  DCI Format Type N1 for User data
 struct DCIFormatN1{
@@ -94,7 +97,6 @@ struct DCIFormatN1{
 
 
 typedef struct DCIFormatN1 DCIFormatN1_t;
-#define sizeof_DCIFormatN1_t 23
 
 ///  DCI Format Type N1 for initial RA
 struct DCIFormatN1_RA{
@@ -111,30 +113,30 @@ struct DCIFormatN1_RA{
 };
 
 typedef struct DCIFormatN1_RA DCIFormatN1_RA_t;
-#define sizeof_DCIFormatN1_RA_t 23
 
-///  DCI Format Type N1 for RAR
+///  DCI Format Type N1 for User data
 struct DCIFormatN1_RAR{
-  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1, 1 bits
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1,1bits
   uint8_t type;
-  //NPDCCH order indicator (set to 0),1 bits
+  //NPDCCH order indicator (set to 0), 1 bits
   uint8_t orderIndicator;
-  // Scheduling Delay, 3 bits
+  // Scheduling Delay,3 bits
   uint8_t Scheddly;
-  // Resourse Assignment (RU Assignment), 3 bits
+  // Resourse Assignment (RU Assignment),3 bits
   uint8_t ResAssign;
-  // Modulation and Coding Scheme, 4 bits
+  // Modulation and Coding Scheme,4 bits
   uint8_t mcs;
-  // Repetition Number, 4 bits
+  // Repetition Number,4 bits
   uint8_t RepNum;
-  // Reserved 5 bits
-  uint8_t Reserved;
-  // DCI subframe repetition Number, 2 bits
+  // New Data Indicator,1 bits,reserved in the RAR
+  uint8_t ndi;
+  // HARQ-ACK resource,4 bits,reserved in the RAR
+  uint8_t HARQackRes;
+  // DCI subframe repetition Number,2 bits
   uint8_t DCIRep;
 };
 
 typedef struct DCIFormatN1_RAR DCIFormatN1_RAR_t;
-#define sizeof_DCIFormatN1_RAR_t 23
 
 //  DCI Format Type N2 for direct indication, 15 bits
 struct DCIFormatN2_Ind{
@@ -147,7 +149,6 @@ struct DCIFormatN2_Ind{
 };
 
 typedef struct DCIFormatN2_Ind DCIFormatN2_Ind_t;
-#define sizeof_DCIFormatN2_Ind_t 15
 
 //  DCI Format Type N2 for Paging, 15 bits
 struct DCIFormatN2_Pag{
@@ -164,9 +165,8 @@ struct DCIFormatN2_Pag{
 };
 
 typedef struct DCIFormatN2_Pag DCIFormatN2_Pag_t;
-#define sizeof_DCIFormatN2_Pag_t 15
 
- typedef union DCI_CONTENT {
+typedef union DCI_CONTENT {
  // 
  DCIFormatN0_t DCIN0;
  //
@@ -181,3 +181,112 @@ typedef struct DCIFormatN2_Pag DCIFormatN2_Pag_t;
  DCIFormatN2_Pag_t DCIN2_Pag;
 
  }DCI_CONTENT;
+
+ /*Structure for packing*/
+
+ struct DCIN0{
+  /// DCI subframe repetition Number, 2 bits
+  uint8_t DCIRep:2;
+  /// New Data Indicator, 1 bits
+  uint8_t ndi:1;
+  /// Repetition Number, 3 bits
+  uint8_t RepNum:3;
+  /// Redundancy version for HARQ (only use 0 and 2), 1 bits
+  uint8_t rv:1;
+  /// Modulation and Coding Scheme, 4 bits
+  uint8_t mcs:4;
+  /// Scheduling Delay, 2 bits
+  uint8_t Scheddly:2;
+  /// Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign:3;
+  /// Subcarrier indication, 6 bits
+  uint8_t scind:6;
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1, 1 bits
+  uint8_t type:1;
+ } __attribute__ ((__packed__));
+
+ typedef struct DCIN0 DCIN0_t;
+#define sizeof_DCIN0_t 23
+
+struct DCIN1_RAR{
+  // DCI subframe repetition Number, 2 bits
+  uint8_t DCIRep:2;
+  // HARQ-ACK resource,4 bits
+  uint8_t HARQackRes:4; 
+  // New Data Indicator,1 bits
+  uint8_t ndi:1;
+  // Repetition Number, 4 bits
+  uint8_t RepNum:4;
+  // Modulation and Coding Scheme, 4 bits
+  uint8_t mcs:4;
+  // Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign:3;
+  // Scheduling Delay, 3 bits
+  uint8_t Scheddly:3;
+  //NPDCCH order indicator (set to 0),1 bits
+  uint8_t orderIndicator:1;
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1, 1 bits
+  uint8_t type:1;
+ } __attribute__ ((__packed__));
+
+ typedef struct DCIN1_RAR DCIN1_RAR_t;
+#define sizeof_DCIN1_RAR_t 23
+
+struct DCIN1{
+  // DCI subframe repetition Number, 2 bits
+  uint8_t DCIRep:2;
+  // HARQ-ACK resource,4 bits
+  uint8_t HARQackRes:4; 
+  // New Data Indicator,1 bits
+  uint8_t ndi:1;
+  // Repetition Number, 4 bits
+  uint8_t RepNum:4;
+  // Modulation and Coding Scheme, 4 bits
+  uint8_t mcs:4;
+  // Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign:3;
+  // Scheduling Delay, 3 bits
+  uint8_t Scheddly:3;
+  //NPDCCH order indicator (set to 0),1 bits
+  uint8_t orderIndicator:1;
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1, 1 bits
+  uint8_t type:1;
+ } __attribute__ ((__packed__));
+
+ typedef struct DCIN1 DCIN1_t;
+#define sizeof_DCIN1_t 23
+
+//  DCI Format Type N2 for direct indication, 15 bits
+struct DCIN2_Ind{
+  // Reserved information bits, 6 bits
+  uint8_t resInfoBits:6;
+  //Direct indication information, 8 bits
+  uint8_t directIndInf:8;
+  //Flag for paging(1)/direct indication(0), set to 0,1 bits
+  uint8_t type:1;
+} __attribute__ ((__packed__));;
+
+typedef struct DCIN2_Ind DCIN2_Ind_t;
+#define sizeof_DCIN2_Ind_t 15
+
+//  DCI Format Type N2 for Paging, 15 bits
+struct DCIN2_Pag{
+  // Reserved 3 bits
+  uint8_t DCIRep:3;
+  // Repetition Number, 4 bits
+  uint8_t RepNum:4;
+  // Modulation and Coding Scheme, 4 bits
+  uint8_t mcs:4;
+  // Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign:3;
+  //Flag for paging(1)/direct indication(0), set to 1,1 bits
+  uint8_t type:1;
+} __attribute__ ((__packed__));;
+
+typedef struct DCIN2_Pag DCIN2_Pag_t;
+
+#define sizeof_DCIN2_Pag_t 15
+
+#define MAX_DCI_SIZE_BITS_NB_IoT 23
+
+#endif

openair1/PHY/LTE_TRANSPORT/defs.h

@@ -168,6 +168,7 @@ typedef struct {
   uint8_t codeword;
 } LTE_DL_eNB_HARQ_t;
 
+
 typedef struct {
   /// Indicator of first transmission
   uint8_t first_tx;
@@ -800,5 +801,9 @@ typedef struct {
 } DCI_ALLOC_t;
 
 
+
+
+//---------------------------------------------------------------------------------------
+
 /**@}*/
 #endif

openair1/PHY/LTE_TRANSPORT/dlsch_coding.c

@@ -234,6 +234,136 @@ LTE_eNB_DLSCH_t *new_eNB_dlsch(unsigned char Kmimo,unsigned char Mdlharq,uint32_
 
 
 }
+/*
+NB_IoT_eNB_NDLSCH_t *new_eNB_dlsch_NB_IoT(//unsigned char Kmimo,
+									//unsigned char Mdlharq,
+									uint32_t Nsoft,
+									//unsigned char N_RB_DL,
+									uint8_t abstraction_flag,
+									NB_IoT_DL_FRAME_PARMS* frame_parms)
+{
+
+  NB_IoT_eNB_NDLSCH_t *dlsch;
+  unsigned char exit_flag = 0,i,j,r,aa,layer;
+  int re;
+  unsigned char bw_scaling =1;
+
+//  switch (N_RB_DL) {
+//  case 6:
+//    bw_scaling =16;
+//    break;
+//
+//  case 25:
+//    bw_scaling =4;
+//    break;
+//
+//  case 50:
+//    bw_scaling =2;
+//    break;
+//
+//  default:
+//    bw_scaling =1;
+//    break;
+//  }
+
+  dlsch = (NB_IoT_eNB_NDLSCH_t *)malloc16(sizeof(NB_IoT_eNB_NDLSCH_t));
+
+  if (dlsch) {
+    bzero(dlsch,sizeof(NB_IoT_eNB_NDLSCH_t));
+
+    dlsch->Mlimit = 4;//max number of retransmission
+    dlsch->Nsoft = Nsoft;
+
+    for (layer=0; layer<4; layer++) {
+      dlsch->ue_spec_bf_weights[layer] = (int32_t**)malloc16(frame_parms->nb_antennas_tx*sizeof(int32_t*));
+
+       for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
+         dlsch->ue_spec_bf_weights[layer][aa] = (int32_t *)malloc16(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES*sizeof(int32_t));
+         for (re=0;re<OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES; re++) {
+           dlsch->ue_spec_bf_weights[layer][aa][re] = 0x00007fff;
+         }
+       }
+     }
+
+     dlsch->calib_dl_ch_estimates = (int32_t**)malloc16(frame_parms->nb_antennas_tx*sizeof(int32_t*));
+     for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
+       dlsch->calib_dl_ch_estimates[aa] = (int32_t *)malloc16(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES*sizeof(int32_t));
+
+     }
+
+
+
+
+    //In NB-IoT we have only 1 HARQ process for each User-------------
+ 
+      dlsch->harq_process = (LTE_DL_eNB_HARQ_t *)malloc16(sizeof(LTE_DL_eNB_HARQ_t));
+      LOG_T(PHY, "[NB-IoT] Required mem size %d (bw scaling %d), dlsch->harq_process %p\n",
+            MAX_DLSCH_PAYLOAD_BYTES/bw_scaling,bw_scaling,dlsch->harq_process);
+
+      if (dlsch->harq_process) {
+        bzero(dlsch->harq_process,sizeof(LTE_DL_eNB_HARQ_t));
+        //    dlsch->harq_processes[i]->first_tx=1;
+        dlsch->harq_process->b = (unsigned char*)malloc16(MAX_DLSCH_PAYLOAD_BYTES/bw_scaling);
+
+        if (dlsch->harq_process->b) {
+          bzero(dlsch->harq_process->b,MAX_DLSCH_PAYLOAD_BYTES/bw_scaling);
+        } else {
+          printf("Can't get b\n");
+          exit_flag=1;
+        }
+
+        if (abstraction_flag==0) {
+
+        //XXX MAX_NUM_DLSCH_SEGMENTS may should be changed for NB-IoT
+          for (r=0; r<MAX_NUM_DLSCH_SEGMENTS/bw_scaling; r++) {
+            // account for filler in first segment and CRCs for multiple segment case
+            dlsch->harq_process->c[r] = (uint8_t*)malloc16(((r==0)?8:0) + 3+ 768);
+            dlsch->harq_process->d[r] = (uint8_t*)malloc16((96+12+3+(3*6144)));
+            if (dlsch->harq_process->c[r]) {
+              bzero(dlsch->harq_process->c[r],((r==0)?8:0) + 3+ 768);
+            } else {
+              printf("Can't get c\n");
+              exit_flag=2;
+            }
+            if (dlsch->harq_process->d[r]) {
+              bzero(dlsch->harq_process->d[r],(96+12+3+(3*6144)));
+            } else {
+              printf("Can't get d\n");
+              exit_flag=2;
+            }
+          }
+        }
+      } else {
+        printf("Can't get harq_p %d\n",i);
+        exit_flag=3;
+      }
+    //---------------------------------------------
+
+    if (exit_flag==0) {
+
+      dlsch->harq_process->round=0;
+
+      for (j=0; j<96; j++)
+    	  for (r=0; r<MAX_NUM_DLSCH_SEGMENTS/bw_scaling; r++) {
+    		  //      printf("dlsch->harq_processes[%d]->d[%d] %p\n",i,r,dlsch->harq_processes[i]->d[r]);
+    		  if (dlsch->harq_process->d[r])
+    			  dlsch->harq_process->d[r][j] = LTE_NULL;
+    	  }
+      return(dlsch);
+    }
+  }
+
+ // memory allocation failed for ndlsch
+
+  LOG_D(PHY,"new_eNB_ndlsch exit flag %d, size of  %ld\n",
+	exit_flag, sizeof(LTE_eNB_DLSCH_t));
+  free_eNB_dlsch(dlsch);
+  return(NULL);
+
+
+}
+
+*/
 
 void clean_eNb_dlsch(LTE_eNB_DLSCH_t *dlsch)
 {
@@ -265,7 +395,7 @@ void clean_eNb_dlsch(LTE_eNB_DLSCH_t *dlsch)
   }
 }
 
-
+/*
 int dlsch_encoding_2threads0(te_params *tep) {
 
   LTE_eNB_DLSCH_t *dlsch          = tep->dlsch;
@@ -556,6 +686,7 @@ int dlsch_encoding_2threads(PHY_VARS_eNB *eNB,
 
   return(0);
 }
+*/
 
 int dlsch_encoding(PHY_VARS_eNB *eNB,
 		   unsigned char *a,

openair1/PHY/LTE_TRANSPORT/dlsch_coding_NB_IoT.c

@@ -11,21 +11,21 @@
 * \note
 * \warning
 */
+#include <string.h>
+//#include "PHY/defs.h"
+//#include "PHY/defs_NB_IoT.h"
+//#include "PHY/extern_NB_IoT.h"
+#include "PHY/CODING/defs_NB_IoT.h"
+//#include "PHY/CODING/extern.h"
+//#include "PHY/CODING/lte_interleaver_inline.h"
+#include "PHY/LTE_TRANSPORT/defs_NB_IoT.h"
+//#include "PHY/LTE_TRANSPORT/proto_NB_IoT.h"
+//#include "SCHED/defs_NB_IoT.h"
+//#include "defs_nb_iot.h"
+//#include "UTIL/LOG/vcd_signal_dumper.h"
+#include "PHY/TOOLS/time_meas_NB_IoT.h" 
 
-#include "PHY/defs.h"
-#include "PHY/extern.h"
-#include "PHY/CODING/defs.h"
-#include "PHY/CODING/extern.h"
-#include "PHY/CODING/lte_interleaver_inline.h"
-#include "PHY/LTE_TRANSPORT/defs.h"
-#include "PHY/LTE_TRANSPORT/proto.h"
-#include "SCHED/defs.h"
-#include "defs.h"
-#include "UTIL/LOG/vcd_signal_dumper.h"
-
-#define is_not_pilot(pilots,first_pilot,re) (1)
-
-#include "PHY/LTE_TRANSPORT/defs_NB_IoT.h" // newly added for NB_IoT
+unsigned char  ccodelte_table2_NB_IoT[128];
 
 void ccode_encode_npdsch_NB_IoT (int32_t   numbits,
 								 uint8_t   *inPtr,
@@ -34,7 +34,7 @@ void ccode_encode_npdsch_NB_IoT (int32_t numbits,
 {
 	uint32_t  	state;
 	uint8_t  	c, out, first_bit;
-	int8_t shiftbit=0;
+	int8_t 		shiftbit = 0;
     /* The input bit is shifted in position 8 of the state.
 	Shiftbit will take values between 1 and 8 */
 	state 		= 0;
@@ -55,7 +55,7 @@ void ccode_encode_npdsch_NB_IoT (int32_t numbits,
 				if ((c&(1<<shiftbit)) != 0) {
 					state |= 64;
 				}
-				out = ccodelte_table_NB_IoT[state];
+				out = ccodelte_table2_NB_IoT[state];
 
 				*outPtr++ = out  & 1;
 				*outPtr++ = (out>>1)&1;
@@ -68,43 +68,45 @@ void ccode_encode_npdsch_NB_IoT (int32_t numbits,
 int dlsch_encoding_NB_IoT(unsigned char      			*a,
 						  NB_IoT_eNB_DLSCH_t 			*dlsch,
 						  uint8_t 			 			Nsf,		// number of subframes required for npdsch pdu transmission calculated from Isf (3GPP spec table)
-						  unsigned int G; 				// G (number of available RE) is implicitly multiplied by 2 (since only QPSK modulation)
-						  time_stats_t *rm_stats,
-						  time_stats_t *te_stats,
-						  time_stats_t *i_stats)
+						  unsigned int 		 			G, 		    // G (number of available RE) is implicitly multiplied by 2 (since only QPSK modulation)
+						  time_stats_t_NB_IoT 		 	*rm_stats,
+						  time_stats_t_NB_IoT 		 	*te_stats,
+						  time_stats_t_NB_IoT 		 	*i_stats)
 {
-	unsigned int crc=1;
+	unsigned int  crc = 1;
 	//unsigned char harq_pid = dlsch->current_harq_pid;  			// to check during implementation if harq_pid is required in the NB_IoT_eNB_DLSCH_t structure  in defs_NB_IoT.h
 	unsigned int  A;
 	uint8_t 	  RCC;
-	A = dlsch->harq_processe->TBS;  				// 680
-	dlsch->harq_processe->length_e = G*Nsf			// G*Nsf (number_of_subframes) = total number of bits to transmit 
+
+	A 							 = dlsch->harq_process.TBS;  				// 680
+	dlsch->harq_process.length_e = G*Nsf;									// G*Nsf (number_of_subframes) = total number of bits to transmit
+
 	int32_t numbits = A+24;
 	
-	if (dlsch->harq_processe->round == 0) { 	    // This is a new packet
+	if (dlsch->harq_process.round == 0) { 	    // This is a new packet
 
-		crc = crc24a(a,A)>>8;						// CRC calculation (24 bits CRC)
+		crc = crc24a_NB_IoT(a,A)>>8;						// CRC calculation (24 bits CRC)
 												    // CRC attachment to payload
 		a[A>>3]     = ((uint8_t*)&crc)[2];
 		a[1+(A>>3)] = ((uint8_t*)&crc)[1];
 		a[2+(A>>3)] = ((uint8_t*)&crc)[0];
 		
-		dlsch->harq_processe->B = numbits;			// The length of table b in bits
+		dlsch->harq_process.B = numbits;			// The length of table b in bits
 		
-		memcpy(dlsch->harq_processe->b,a,numbits/8); 
-		memset(dlsch->harq_processe->d,LTE_NULL,96);
+		memcpy(dlsch->harq_process.b,a,numbits/8); 
+		memset(dlsch->harq_process.d,LTE_NULL_NB_IoT,96);
 		
-		start_meas(te_stats);
-		ccode_encode_npdsch_NB_IoT(numbits, dlsch->harq_processe->b, dlsch->harq_processe->d+96, crc);  					//   step 1 Tail-biting convolutional coding
-		stop_meas(te_stats);
+		start_meas_NB_IoT(te_stats);
+		ccode_encode_npdsch_NB_IoT(numbits, dlsch->harq_process.b, dlsch->harq_process.d+96, crc);  					//   step 1 Tail-biting convolutional coding
+		stop_meas_NB_IoT(te_stats);
 		
-		start_meas(i_stats);
-		RCC = sub_block_interleaving_cc_NB_IoT(numbits,dlsch->harq_processe->d+96,dlsch->harq_processe->w);					//   step 2 interleaving
-		stop_meas(i_stats);
+		start_meas_NB_IoT(i_stats);
+		RCC = sub_block_interleaving_cc_NB_IoT(numbits,dlsch->harq_process.d+96,dlsch->harq_process.w);					//   step 2 interleaving
+		stop_meas_NB_IoT(i_stats);
 		
-		start_meas(rm_stats);
-		lte_rate_matching_cc_NB_IoT(RCC,dlsch->harq_processe->length_e,dlsch->harq_processe->w,dlsch->harq_processe->e);    // step 3 Rate Matching
-		stop_meas(rm_stats);		
+		start_meas_NB_IoT(rm_stats);
+		lte_rate_matching_cc_NB_IoT(RCC,dlsch->harq_process.length_e,dlsch->harq_process.w,dlsch->harq_process.e);    // step 3 Rate Matching
+		stop_meas_NB_IoT(rm_stats);		
     }
   return(0);
 }

openair1/PHY/LTE_TRANSPORT/dlsch_tbs_full.h

@@ -19,6 +19,10 @@
  *      contact@openairinterface.org
  */
 
+
+#ifndef __DLSCH_TBS_FULL_H__
+#define __DLSCH_TBS_FULL_H__
+
 #define TBStable_rowCnt 27
 
 /** \brief "Transport block size table"
@@ -54,3 +58,10 @@ unsigned int TBStable[TBStable_rowCnt][110] = {{16,32,56,88,120,152,176,208,224,
 };
 
 unsigned int TBStable1C[32] = {40, 56, 72, 120, 136, 144, 176, 208, 224, 256, 280, 296, 328, 336, 392, 488, 552, 600, 632, 696, 776, 840, 904, 1000, 1064, 1128, 1224, 1288, 1384, 1480, 1608, 1736};
+
+
+
+#endif
+
+
+

openair1/PHY/LTE_TRANSPORT/extern.h

@@ -20,6 +20,7 @@
  */
 
 extern unsigned int dlsch_tbs25[27][25],TBStable[27][110],TBStable1C[32];
+
 extern unsigned short lte_cqi_eff1024[16];
 extern char lte_cqi_snr_dB[15];
 extern short conjugate[8],conjugate2[8];

openair1/PHY/LTE_TRANSPORT/initial_sync.c

@@ -36,6 +36,7 @@
 #include "SCHED/extern.h"
 #include "defs.h"
 #include "extern.h"
+#include "PHY/LTE_REFSIG/defs.h"
 
 
 #include "common_lib.h"

openair1/PHY/LTE_TRANSPORT/pucch.c

@@ -1263,7 +1263,7 @@ uint16_t pucchfmt3_ChannelEstimation( int16_t SubCarrierDeMapData[NB_ANTENNAS_RX
     int32_t         IP_CsData_allsfavg[NB_ANTENNAS_RX][14][4][2];
     int32_t         IP_allavg[D_NPUCCH_SF5];
     //int16_t         temp_ch[2];
-	int16_t         m[NUMBER_OF_UE_MAX], m_self, same_m_number;
+	int16_t         m[NUMBER_OF_UE_MAX], m_self=0, same_m_number;
 	uint16_t        n3_pucch_sameRB[NUMBER_OF_UE_MAX];
 	int16_t         n_oc0[NUMBER_OF_UE_MAX];
 	int16_t         n_oc1[NUMBER_OF_UE_MAX];