Merge branch 'nr_pdcch' into develop-nr

cmake_targets/CMakeLists.txt

@@ -1117,23 +1117,19 @@ set(PHY_TURBOSRC
   ${OPENAIR1_DIR}/PHY/CODING/3gpplte_turbo_decoder.c
 )
 set(PHY_POLARSRC
-  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_init.c
+  ${OPENAIR1_DIR}/PHY/CODING/nr_polar_init.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_crc_byte.c
-  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_bit_insertion.c
-  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_channel_interleaver_pattern.c
- # ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_crc.c
+  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_crc.c
+  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_decoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c
-  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_info_bit_pattern.c
+  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_encoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_interleaving_pattern.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_kernal_operation.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_kronecker_power_matrices.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_matrix_and_array.c
-  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_output_length.c
-  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_rate_match.c
+  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_procedures.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_sequence_pattern.c
-  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_encoder.c
-  ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_decoder.c
 )
 set(PHY_TURBOIF
   ${OPENAIR1_DIR}/PHY/CODING/coding_load.c
@@ -1176,6 +1172,8 @@ set(PHY_SRC_COMMON
   ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_dl_mbsfn.c
   ${OPENAIR1_DIR}/PHY/LTE_REFSIG/lte_ul_ref.c
   ${OPENAIR1_DIR}/PHY/CODING/lte_segmentation.c
+  ${OPENAIR1_DIR}/PHY/CODING/nr_segmentation.c
+  ${OPENAIR1_DIR}/PHY/CODING/nr_compute_tbs.c
   ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte.c
   ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte_lte.c
   ${OPENAIR1_DIR}/PHY/CODING/3gpplte_sse.c
@@ -1291,6 +1289,8 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_pss.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_sss.c
   ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_pbch.c
+  ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_dci.c
+  ${OPENAIR1_DIR}/PHY/NR_TRANSPORT/nr_dci_tools.c
   ${OPENAIR1_DIR}/PHY/NR_REFSIG/nr_gold.c
   ${OPENAIR1_DIR}/PHY/TOOLS/file_output.c
   ${OPENAIR1_DIR}/PHY/TOOLS/cadd_vv.c
@@ -1455,7 +1455,7 @@ set(L2_SRC
   ${RRC_DIR}/L2_interface_ue.c
   )
 
-set(NR_L2_SRC
+set(L2_NR_SRC
   ${NR_RRC_DIR}/rrc_gNB.c
   ${NR_RRC_DIR}/nr_rrc_common.c
   ${NR_RRC_DIR}/L2_nr_interface.c
@@ -1511,6 +1511,12 @@ set(NR_L2_SRC_UE
 #${RRC_DIR}/rrc_UE.c
   )
 
+set(L2_NR_SRC_UE
+  ${NR_UE_RRC_DIR}/L2_interface_ue.c
+  ${NR_UE_RRC_DIR}/main_ue.c
+  ${NR_UE_RRC_DIR}/rrc_UE.c
+  )
+
 set (MAC_SRC
   #${PHY_INTERFACE_DIR}/phy_stub_UE.c
   ${PHY_INTERFACE_DIR}/IF_Module.c
@@ -1533,15 +1539,16 @@ set (MAC_SRC
   ${MAC_DIR}/pre_processor.c
   ${MAC_DIR}/config.c
   ${MAC_DIR}/config_ue.c
-  )
+ )
 
-set (NR_MAC_SRC
+set (MAC_NR_SRC
   ${NR_PHY_INTERFACE_DIR}/NR_IF_Module.c
   ${NR_MAC_DIR}/main.c
   ${NR_MAC_DIR}/config.c
   ${NR_MAC_DIR}/gNB_scheduler.c
   ${NR_MAC_DIR}/gNB_scheduler_bch.c
   ${NR_MAC_DIR}/gNB_scheduler_primitives.c
+  ${NR_MAC_DIR}/gNB_scheduler_phytest.c
  )
 
 
@@ -1579,11 +1586,12 @@ add_library(L2
   ${L2_SRC}
   ${MAC_SRC}
   ${ENB_APP_SRC}
-)
+  )
+#  ${OPENAIR2_DIR}/RRC/L2_INTERFACE/openair_rrc_L2_interface.c)
 
-add_library(NR_L2
-  ${NR_L2_SRC}
-  ${NR_MAC_SRC}
+add_library(L2_NR
+  ${L2_NR_SRC}
+  ${MAC_NR_SRC}
   ${GNB_APP_SRC}
   )
 
@@ -2201,7 +2209,7 @@ add_executable(lte-softmodem
 
 target_link_libraries (lte-softmodem
   -Wl,--start-group
-  RRC_LIB S1AP_LIB S1AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB PHY_COMMON PHY PHY_RU LFDS L2 
+  RRC_LIB S1AP_LIB S1AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB PHY_COMMON PHY PHY_RU LFDS L2
   ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7
   NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
   -Wl,--end-group z dl)
@@ -2355,8 +2363,8 @@ add_executable(nr-softmodem
 target_link_libraries (nr-softmodem
   -Wl,--start-group
   UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_RU LFDS GTPV1U SECU_CN SECU_OSA
-  ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ATLAS_LIBRARIES}
-  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 NR_L2
+  ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB}
+  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR
   NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
   -Wl,--end-group z dl)
 
@@ -2377,6 +2385,7 @@ add_executable(nr-softmodem-nos1
   ${OPENAIR_TARGETS}/RT/USER/nr-ru.c
   ${OPENAIR_TARGETS}/RT/USER/nr-softmodem.c
   ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
+  ${OPENAIR_TARGETS}/COMMON/create_tasks.c
   ${OPENAIR_TARGETS}/COMMON/create_nr_tasks.c
   ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
   ${OPENAIR2_DIR}/RRC/NAS/nas_config.c
@@ -2396,7 +2405,7 @@ target_link_libraries (nr-softmodem-nos1
   -Wl,--start-group
   UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_RU LFDS GTPV1U SECU_CN SECU_OSA
   ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${MIH_LIB}
-  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 NR_L2
+  RRC_LIB NR_RRC_LIB S1AP_LIB S1AP_ENB L2 L2_NR
   NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB
   -Wl,--end-group z dl)
 

nfapi/oai_integration/nfapi_vnf.c

@@ -1134,7 +1134,6 @@ int oai_nfapi_nr_dl_config_req(nfapi_nr_dl_config_request_t *dl_config_req)
 
   int retval = nfapi_vnf_p7_dl_config_req(p7_config, dl_config_req);
 
-  dl_config_req->dl_config_request_body.number_pdcch_ofdm_symbols           = 1;
   dl_config_req->dl_config_request_body.number_dci                          = 0;
   dl_config_req->dl_config_request_body.number_pdu                          = 0;
   dl_config_req->dl_config_request_body.number_pdsch_rnti                   = 0;

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

@@ -37,8 +37,8 @@ typedef struct {
     uint8_t sul_ind_0_1                     ; // 2  SUL_IND_0_1:
     uint8_t slot_format_ind                 ; // 3  SLOT_FORMAT_IND: size of DCI format 2_0 is configurable by higher layers up to 128 bits, according to Subclause 11.1.1 of [5, TS 38.213]
     uint8_t pre_emption_ind                 ; // 4  PRE_EMPTION_IND: size of DCI format 2_1 is configurable by higher layers up to 126 bits, according to Subclause 11.2 of [5, TS 38.213]. Each pre-emption indication is 14 bits
-    uint8_t tpc_cmd_number                  ; // 5  TPC_CMD_NUMBER: The parameter xxx provided by higher layers determines the index to the TPC command number for an UL of a cell. Each TPC command number is 2 bits
-    uint8_t block_number                    ; // 6  BLOCK_NUMBER: starting position of a block is determined by the parameter startingBitOfFormat2_3
+    uint8_t block_number                    ; // 5  BLOCK_NUMBER: starting position of a block is determined by the parameter startingBitOfFormat2_3
+    uint8_t close_loop_ind                  ; // 6  CLOSE_LOOP_IND:
     uint8_t bandwidth_part_ind              ; // 7  BANDWIDTH_PART_IND:
     uint8_t short_message_ind               ; // 8  SHORT_MESSAGE_IND:
     uint8_t short_messages                  ; // 9  SHORT_MESSAGES:
@@ -81,7 +81,7 @@ typedef struct {
     uint8_t antenna_ports                   ; // 38 ANTENNA_PORTS:
     uint8_t tci                             ; // 39 TCI: 0 bit if higher layer parameter tci-PresentInDCI is not enabled; otherwise 3 bits
     uint8_t srs_request                     ; // 40 SRS_REQUEST:
-    uint8_t tpc_cmd_number_format2_3        ; // 41 TPC_CMD_NUMBER_FORMAT2_3:
+    uint8_t tpc_cmd                         ; // 41 TPC_CMD:
     uint8_t csi_request                     ; // 42 CSI_REQUEST:
     uint8_t cbgti                           ; // 43 CBGTI: 0, 2, 4, 6, or 8 bits determined by higher layer parameter maxCodeBlockGroupsPerTransportBlock for the PDSCH
     uint8_t cbgfi                           ; // 44 CBGFI: 0 or 1 bit determined by higher layer parameter codeBlockGroupFlushIndicator
@@ -237,15 +237,34 @@ typedef struct {
     typedef struct {
 
     } fapi_nr_ul_config_pucch_pdu;
-
+    typedef enum {pusch_freq_hopping_disabled = 0 , pusch_freq_hopping_enabled = 1}pusch_freq_hopping_t;
+    typedef struct{
+    uint8_t aperiodicSRS_ResourceTrigger;
+    } fapi_nr_ul_srs_config_t;
     typedef struct {
+        uint8_t bandwidth_part_ind;
         uint16_t number_rbs;
         uint16_t start_rb;
+        uint8_t frame_offset;
         uint16_t number_symbols;
         uint16_t start_symbol;
+        pusch_freq_hopping_t pusch_freq_hopping;
         uint8_t mcs;
-        uint8_t tpc_command;
+        uint8_t ndi;
         uint8_t rv;
+        uint8_t harq_process_nbr;
+        int8_t accumulated_delta_PUSCH;
+        int8_t absolute_delta_PUSCH;
+        uint8_t n_layers;
+        uint8_t tpmi;
+        uint8_t n_dmrs_cdm_groups;
+        uint8_t dmrs_ports[4];
+        uint8_t n_front_load_symb;
+        fapi_nr_ul_srs_config_t srs_config;
+        uint8_t csi_reportTriggerSize;
+        uint8_t maxCodeBlockGroupsPerTransportBlock;
+        uint8_t ptrs_dmrs_association_port;
+        uint8_t beta_offset_ind;
     } fapi_nr_ul_config_pusch_pdu_rel15_t;
 
     typedef struct {
@@ -290,17 +309,43 @@ typedef struct {
     typedef struct {
         fapi_nr_dl_config_dci_dl_pdu_rel15_t dci_config_rel15;
     } fapi_nr_dl_config_dci_pdu;
+    typedef struct{
+    uint8_t aperiodicSRS_ResourceTrigger;
+    } fapi_nr_dl_srs_config_t;
 
+    typedef enum{vrb_to_prb_mapping_non_interleaved = 0, vrb_to_prb_mapping_interleaved = 1} vrb_to_prb_mapping_t;
+    //typedef fapi_nr_dci_pdu_rel15_t fapi_nr_dl_config_dlsch_pdu_rel15_t;
     typedef struct {
+        uint8_t bandwidth_part_ind;
         uint16_t number_rbs;
         uint16_t start_rb;
+        uint8_t frame_offset;
         uint16_t number_symbols;
         uint16_t start_symbol;
+        uint8_t prb_bundling_size_ind;
+        uint8_t rate_matching_ind;
+        uint8_t zp_csi_rs_trigger;
         uint8_t mcs;
-        uint8_t rv;
-        uint8_t harq_pid;
         uint8_t ndi;
-        //  TODO: check the fields needed to L1 with NR_DL_UE_HARQ_t and NR_UE_DLSCH_t
+        uint8_t rv;
+        uint8_t tb2_mcs;
+        uint8_t tb2_ndi;
+        uint8_t tb2_rv;
+        uint8_t harq_process_nbr;
+        vrb_to_prb_mapping_t vrb_to_prb_mapping;
+        uint8_t dai;
+        double scaling_factor_S;
+        int8_t accumulated_delta_PUCCH;
+        uint8_t pucch_resource_id;
+        uint8_t pdsch_to_harq_feedback_time_ind;
+        uint8_t n_dmrs_cdm_groups;
+        uint8_t dmrs_ports[10];
+        uint8_t n_front_load_symb;
+        uint8_t tci_state;
+        fapi_nr_dl_srs_config_t srs_config;
+        uint8_t cbgti;
+        uint8_t codeBlockGroupFlushIndicator;
+        //  to be check the fields needed to L1 with NR_DL_UE_HARQ_t and NR_UE_DLSCH_t
     } fapi_nr_dl_config_dlsch_pdu_rel15_t;
 
     typedef struct {
@@ -598,7 +643,7 @@ typedef struct {
     typedef struct {
         uint8_t dmrs_type;
         uint8_t dmrs_addition_position;
-        
+        uint8_t ptrs_uplink_config; // to indicate if PTRS Uplink is configured of not
         uint8_t ptrs_type;  //cp-OFDM, dft-S-OFDM
         uint16_t ptrs_frequency_density[2];
         uint8_t ptrs_time_density[3];
@@ -624,9 +669,15 @@ typedef struct {
         uint8_t delta_mcs;
     } fapi_nr_pusch_power_control_t;
 
+    typedef enum {tx_config_codebook = 1, tx_config_nonCodebook = 2} tx_config_t;
+    typedef enum {transform_precoder_disabled = 0, transform_precoder_enabled = 1} transform_precoder_t;
+    typedef enum {
+      codebook_subset_fullyAndPartialAndNonCoherent = 1,
+      codebook_subset_partialAndNonCoherent = 2,
+      codebook_subset_nonCoherent = 3} codebook_subset_t;
     typedef struct {
         uint16_t data_scrambling_identity;
-        uint8_t tx_config;
+        tx_config_t tx_config;
         fapi_nr_dmrs_uplink_config_t dmrs_ul_for_pusch_mapping_type_a;
         fapi_nr_dmrs_uplink_config_t dmrs_ul_for_pusch_mapping_type_b;
         fapi_nr_pusch_power_control_t pusch_power_control;
@@ -637,8 +688,8 @@ typedef struct {
         uint8_t pusch_aggregation_factor;
         uint8_t mcs_table;
         uint8_t mcs_table_transform_precoder;
-        uint8_t transform_precoder;
-        uint8_t codebook_subset;
+        transform_precoder_t transform_precoder;
+        codebook_subset_t codebook_subset;
         uint8_t max_rank;
         uint8_t rbg_size;
 

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

@@ -11,6 +11,30 @@
 
 #include "nfapi_interface.h"
 
+
+#define NFAPI_NR_MAX_NB_CCE_AGGREGATION_LEVELS 5
+
+// Extension to the generic structures for single tlv values
+typedef struct {
+	nfapi_tl_t tl;
+	int32_t value;
+} nfapi_int32_tlv_t;
+
+typedef struct {
+	nfapi_tl_t tl;
+	uint32_t value;
+} nfapi_uint32_tlv_t;
+
+/*typedef struct {
+	nfapi_tl_t tl;
+	int64_t value;
+} nfapi_int64_tlv_t;
+
+typedef struct {
+	nfapi_tl_t tl;
+	uint64_t value;
+} nfapi_uint64_tlv_t;*/
+
 // nFAPI enums
 typedef enum {
   NFAPI_NR_DL_CONFIG_DCI_DL_PDU_TYPE = 0,
@@ -159,6 +183,7 @@ typedef struct {
   nfapi_uint16_tlv_t  ssb_periodicity;
   nfapi_uint16_tlv_t  ss_pbch_block_power;
   nfapi_uint16_tlv_t  n_ssb_crb;
+  nfapi_uint16_tlv_t  rmsi_pdcch_config;
 } nfapi_nr_sch_config_t;
 
 #define NFAPI_NR_SCH_CONFIG_PHYSICAL_CELL_ID_TAG 0x501E
@@ -268,13 +293,10 @@ typedef enum {
   NFAPI_NR_DL_DCI_FORMAT_2_0,
   NFAPI_NR_DL_DCI_FORMAT_2_1,
   NFAPI_NR_DL_DCI_FORMAT_2_2,
-  NFAPI_NR_DL_DCI_FORMAT_2_3
-} nfapi_nr_dl_dci_format_e;
-
-typedef enum {
-  NFAPI_NR_UL_DCI_FORMAT_0_0 = 0,
-  NFAPI_NR_UL_DCI_FORMAT_1_0,
-} nfapi_nr_ul_dci_format_e;
+  NFAPI_NR_DL_DCI_FORMAT_2_3,
+  NFAPI_NR_UL_DCI_FORMAT_0_0,
+  NFAPI_NR_UL_DCI_FORMAT_0_1
+} nfapi_nr_dci_format_e;
 
 typedef enum {
 	NFAPI_NR_RNTI_new = 0,
@@ -290,73 +312,62 @@ typedef enum {
 	NFAPI_NR_RNTI_TPC_PUSCH,
 	NFAPI_NR_RNTI_TPC_PUCCH,
 	NFAPI_NR_RNTI_TPC_SRS
-} nfapi_nr_rnti_type_e ;
+} nfapi_nr_rnti_type_e;
 
-// P7 Sub Structures
-//formats 0_0 and 0_1
-typedef struct {
+typedef enum {
+  NFAPI_NR_USS_FORMAT_0_0_AND_1_0,
+  NFAPI_NR_USS_FORMAT_0_1_AND_1_1,
+} nfapi_nr_uss_dci_formats_e;
 
-nfapi_tl_t tl;
+typedef enum {
+  NFAPI_NR_SEARCH_SPACE_TYPE_COMMON=0,
+  NFAPI_NR_SEARCH_SPACE_TYPE_UE_SPECIFIC
+} nfapi_nr_search_space_type_e;
 
-uint8_t cce_idx;
-uint8_t aggregation_level;
-uint16_t rnti;
+typedef enum {
+  NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE1=0,
+  NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE2,
+  NFAPI_NR_SSB_AND_CSET_MUX_PATTERN_TYPE3
+} nfapi_nr_ssb_and_cset_mux_pattern_type_e;
 
-uint8_t dci_format; //1 bit
-uint16_t frequency_domain_resource_assignment; //up to 9 bits
-uint8_t time_domain_resource_assignment; //0, 1, 2, 3 or 4 bits
-uint8_t frequency_hopping_flag; //1 bit
-uint8_t mcs; //5 bits
-uint8_t new_data_indicator; //1 bit
-uint8_t redundancy_version; //2 bits
-uint8_t harq_process; //4 bits
-uint8_t tpc; //2 bits
-uint16_t padding;
-uint8_t ul_sul_indicator; //0 or 1 bit
+typedef enum {
+  NFAPI_NR_CCE_REG_MAPPING_INTERLEAVED=0,
+  NFAPI_NR_CCE_REG_MAPPING_NON_INTERLEAVED
+} nfapi_nr_cce_reg_mapping_type_e;
 
-uint8_t carrier_indicator; //0 or 3 bits
-uint8_t bwp_indicator; //0, 1 or 2 bits
-uint8_t downlink_assignment_index1; //1 or 2 bits
-uint8_t downlink_assignment_index2; //0 or 2 bits
-uint8_t srs_resource_indicator;
-uint8_t precoding_information;
-uint8_t antenna_ports;
-uint8_t srs_request;
-uint8_t csi_request;
-uint8_t cbgti; //CBG Transmission Information: 0, 2, 4, 6 or 8 bits
-uint8_t ptrs_dmrs_association;
-uint8_t beta_offset_indicator; //0 or 2 bits
-uint8_t dmrs_sequence_initialization; //0 or 1 bit
-uint8_t ul_sch_indicator; //1 bit
+typedef enum {
+  NFAPI_NR_CSET_CONFIG_MIB_SIB1=0,
+  NFAPI_NR_CSET_CONFIG_PDCCH_CONFIG
+} nfapi_nr_coreset_config_type_e;
 
-} nfapi_nr_ul_config_dci_ul_pdu_rel15_t;
-//#define NFAPI_NR_UL_CONFIG_REQUEST_DCI_UL_PDU_REL15_TAG 0x????
+typedef enum {
+  NFAPI_NR_CSET_SAME_AS_REG_BUNDLE=0,
+  NFAPI_NR_CSET_ALL_CONTIGUOUS_RBS
+} nfapi_nr_coreset_precoder_granularity_type_e;
+
+// P7 Sub Structures
 
-//formats 1_0, 1_1, 2_0, 2_1, 2_2 and 2_3
 typedef struct {
 
 nfapi_tl_t tl;
 
-uint8_t cce_idx;
-uint8_t aggregation_level;
-uint16_t rnti;
-
-uint8_t dci_format; //1 bit
-uint16_t frequency_domain_resource_assignment; //up to 9 bits
+uint8_t format_indicator; //1 bit
+uint16_t frequency_domain_assignment; //up to 16 bits
+uint8_t time_domain_assignment; // 4 bits
+uint8_t frequency_hopping_flag; //1 bit
 
 uint8_t ra_preamble_index; //6 bits
-uint8_t ul_sul_indicator; //1 bit
 uint8_t ss_pbch_index; //6 bits
 uint8_t prach_mask_index; //4 bits
-uint16_t reserved; //1_0/C-RNTI:10 bits, 1_0/P-RNTI: 6 bits, 1_0/SI-&RA-RNTI: 16 bits
 
-uint8_t time_domain_resource_assignment; //0, 1, 2, 3 or 4 bits
 uint8_t vrb_to_prb_mapping; //0 or 1 bit
 uint8_t mcs; //5 bits
-uint8_t new_data_indicator; //1 bit
-uint8_t redundancy_version; //2 bits
-uint8_t harq_process; //4 bits
-uint8_t downlink_assignment_index; //0, 2 or 4 bits
+uint8_t ndi; //1 bit
+uint8_t rv; //2 bits
+uint8_t harq_pid; //4 bits
+uint8_t dai; //0, 2 or 4 bits
+uint8_t dai1; //1 or 2 bits
+uint8_t dai2; //0 or 2 bits
 uint8_t tpc; //2 bits
 uint8_t pucch_resource_indicator; //3 bits
 uint8_t pdsch_to_harq_feedback_timing_indicator; //0, 1, 2 or 3 bits
@@ -370,13 +381,18 @@ uint8_t bwp_indicator; //0, 1 or 2 bits
 uint8_t prb_bundling_size_indicator; //0 or 1 bits
 uint8_t rate_matching_indicator; //0, 1 or 2 bits
 uint8_t zp_csi_rs_trigger; //0, 1 or 2 bits
-uint8_t antenna_ports; //4, 5 or 6 bits
 uint8_t transmission_configuration_indication; //0 or 3 bits
 uint8_t srs_request; //2 bits
 uint8_t cbgti; //CBG Transmission Information: 0, 2, 4, 6 or 8 bits
 uint8_t cbgfi; //CBG Flushing Out Information: 0 or 1 bit
 uint8_t dmrs_sequence_initialization; //0 or 1 bit
 
+uint8_t srs_resource_indicator;
+uint8_t precoding_information;
+uint8_t csi_request;
+uint8_t ptrs_dmrs_association;
+uint8_t beta_offset_indicator; //0 or 2 bits
+
 uint8_t slot_format_indicator_count;
 uint8_t *slot_format_indicators;
 
@@ -386,17 +402,75 @@ uint16_t *pre_emption_indications; //14 bit
 uint8_t block_number_count;
 uint8_t *block_numbers;
 
+uint8_t ul_sul_indicator; //0 or 1 bit
+uint8_t antenna_ports;
+
+uint16_t reserved; //1_0/C-RNTI:10 bits, 1_0/P-RNTI: 6 bits, 1_0/SI-&RA-RNTI: 16 bits
+uint16_t padding;
+
 } nfapi_nr_dl_config_dci_dl_pdu_rel15_t;
 
 //#define NFAPI_NR_DL_CONFIG_REQUEST_DCI_DL_PDU_REL15_TAG 0x????
 
-typedef struct {
-  nfapi_nr_dl_config_dci_dl_pdu_rel15_t   dci_dl_pdu_rel15;
-} nfapi_nr_dl_config_dci_dl_pdu;
+typedef struct{
+  nfapi_tl_t tl;
+  uint8_t  coreset_id;
+  uint64_t  frequency_domain_resources;
+  uint8_t  duration;
+  uint8_t  cce_reg_mapping_type;
+  uint8_t  reg_bundle_size;
+  uint8_t  interleaver_size;
+  uint8_t  shift_index;
+  uint8_t  precoder_granularity;
+  uint8_t  tci_state_id;
+  uint8_t  tci_present_in_dci;
+  uint32_t dmrs_scrambling_id;
+} nfapi_nr_coreset_t;
+
+typedef struct{
+  nfapi_tl_t tl;
+  uint8_t   search_space_id;
+  uint8_t   coreset_id;
+  uint8_t   search_space_type;
+  uint8_t   duration;
+  uint8_t   css_formats_0_0_and_1_0;
+  uint8_t   css_format_2_0;
+  uint8_t   css_format_2_1;
+  uint8_t   css_format_2_2;
+  uint8_t   css_format_2_3;
+  uint8_t   uss_dci_formats;
+  uint8_t   srs_monitoring_periodicity;
+  uint8_t   slot_monitoring_periodicity;
+  uint8_t   slot_monitoring_offset;
+  uint16_t  monitoring_symbols_in_slot;
+  uint16_t  number_of_candidates[NFAPI_NR_MAX_NB_CCE_AGGREGATION_LEVELS];
+} nfapi_nr_search_space_t;
 
 typedef struct {
-  nfapi_nr_ul_config_dci_ul_pdu_rel15_t   dci_ul_pdu_rel15;
-} nfapi_nr_ul_config_dci_ul_pdu;
+  nfapi_tl_t tl;
+  uint8_t rnti;
+  uint8_t rnti_type;
+  uint8_t dci_format;
+  uint8_t config_type;
+  uint8_t search_space_type;  
+  uint8_t aggregation_level;
+  uint8_t n_rb;
+  uint8_t n_symb;
+  uint8_t rb_offset;
+  uint8_t cr_mapping_type;
+  uint8_t reg_bundle_size;
+  uint8_t interleaver_size;
+  uint8_t shift_index;
+  uint8_t mux_pattern;
+  uint8_t precoder_granularity;
+  uint8_t first_slot;
+  uint8_t first_symbol;
+  uint8_t nb_ss_sets_per_slot;
+  uint8_t nb_slots;
+  uint8_t sfn_mod2;
+  uint16_t scrambling_id;
+  nfapi_bf_vector_t   bf_vector;
+} nfapi_nr_dl_config_pdcch_parameters_rel15_t;
 
 typedef struct {
   nfapi_tl_t tl;
@@ -411,13 +485,20 @@ typedef struct {
 } nfapi_nr_dl_config_bch_pdu;
 
 typedef struct {
-
-} nfapi_nr_dl_config_dlsch_pdu;
+  nfapi_tl_t tl;
+  nfapi_nr_search_space_t           sib1searchSpace;
+  nfapi_nr_coreset_t   sib1ControlResourceSets;
+  nfapi_nr_search_space_t           sibssearchSpace;
+  nfapi_nr_coreset_t   sibsControlResourceSets; 
+  nfapi_nr_search_space_t           ra_SearchSpace;
+  nfapi_nr_coreset_t   ra_ControlResourceSets;
+}nfapi_nr_dl_config_dlsch_pdu_rel15_t;
 
 typedef struct {
   nfapi_tl_t tl;
-  nfapi_nr_SearchSpace_t           pagingSearchSpace;
-} nfapi_nr_dl_config_pch_pdu;
+  nfapi_nr_search_space_t           pagingSearchSpace;
+  nfapi_nr_coreset_t   pagingControlResourceSets;
+}nfapi_nr_dl_config_pch_pdu_rel15_t;
 
 typedef struct {
   
@@ -431,26 +512,31 @@ typedef struct {
   
 } nfapi_nr_dl_config_ndlsch_pdu;
 
+typedef struct {
+  nfapi_nr_dl_config_dci_dl_pdu_rel15_t     dci_dl_pdu_rel15;
+  nfapi_nr_dl_config_pdcch_parameters_rel15_t pdcch_params_rel15;
+} nfapi_nr_dl_config_dci_dl_pdu;
+
+
 typedef struct {
   uint8_t pdu_type;
   uint8_t pdu_size;
+
   union {
-    nfapi_nr_dl_config_dci_dl_pdu     dci_dl_pdu;
-    nfapi_nr_ul_config_dci_ul_pdu     dci_ul_pdu;
-    nfapi_nr_dl_config_bch_pdu        bch_pdu;
-    nfapi_nr_dl_config_dlsch_pdu      dlsch_pdu;
-    nfapi_nr_dl_config_pch_pdu        pch_pdu;
-    nfapi_nr_dl_config_nbch_pdu       nbch_pdu;
-    nfapi_nr_dl_config_npdcch_pdu     npdcch_pdu;
-    nfapi_nr_dl_config_ndlsch_pdu     ndlsch_pdu;
+  nfapi_nr_dl_config_dci_dl_pdu             dci_dl_pdu;
+  nfapi_nr_dl_config_bch_pdu_rel15_t        bch_pdu_rel15;
+  nfapi_nr_dl_config_dlsch_pdu_rel15_t      dlsch_pdu_rel15;
+  nfapi_nr_dl_config_pch_pdu_rel15_t        pch_pdu_rel15;
+  //nfapi_nr_dl_config_nbch_pdu_rel15_t       nbch_pdu_rel15;
+  //nfapi_nr_dl_config_npdcch_pdu_rel15_t     npdcch_pdu_rel15;
+  //nfapi_nr_dl_config_ndlsch_pdu_rel15_t     ndlsch_pdu_rel15;
   };
 } nfapi_nr_dl_config_request_pdu_t;
  
 typedef struct {
   nfapi_tl_t tl;
-  uint8_t number_pdcch_ofdm_symbols;
   uint8_t   number_dci;
-  uint16_t  number_pdu;
+  uint8_t   number_pdu;
   uint8_t   number_pdsch_rnti;
   nfapi_nr_dl_config_request_pdu_t *dl_config_pdu_list;
 } nfapi_nr_dl_config_request_body_t;

openair1/PHY/CODING/coding_defs.h

@@ -355,8 +355,16 @@ based on 3GPP UMTS/LTE specifications.
 @param inPtr Pointer to input byte stream
 @param bitlen length of inputs in bits
 */
-unsigned int crc24b (unsigned char * inptr, int bitlen);
-    
+uint32_t crc24b (uint8_t *inPtr, int32_t bitlen);
+
+/*!\fn uint32_t crc24c(uint8_t *inPtr, int32_t bitlen)
+\brief This computes a 24-bit crc ('c' variant for transport-block segments)
+based on 3GPP Rel 15 specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits
+*/
+uint32_t crc24c (uint8_t *inPtr, int32_t bitlen);
+
 /*!\fn uint32_t crc16(uint8_t *inPtr, int32_t bitlen)
 \brief This computes a 16-bit crc based on 3GPP UMTS specifications.
 @param inPtr Pointer to input byte stream
@@ -440,4 +448,20 @@ decoder_if_t phy_threegpplte_turbo_decoder;
 decoder_if_t phy_threegpplte_turbo_decoder8;
 decoder_if_t phy_threegpplte_turbo_decoder16;
 
+int32_t nr_segmentation(unsigned char *input_buffer,
+                     unsigned char **output_buffers,
+                     unsigned int B,
+                     unsigned int *C,
+                     unsigned int *Kplus,
+                     unsigned int *Kminus,
+					 unsigned int *Zout,
+                     unsigned int *F);
+
+uint32_t nr_compute_tbs(uint8_t mcs,
+						uint16_t nb_rb,
+						uint16_t nb_symb_sch,
+						uint8_t nb_re_dmrs,
+						uint16_t length_dmrs,
+						uint8_t Nl);
+
 #endif

openair1/PHY/CODING/crc_byte.c

@@ -35,9 +35,12 @@
 
 /*ref 36-212 v8.6.0 , pp 8-9 */
 /* the highest degree is set by default */
-unsigned int             poly24a = 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 = 0x80006300;    // 1000 0000 0000 0000 0110 0011  D^24 + D^23 + D^6 + D^5 + D + 1
-uint32_t poly24c = 0xB2B11700; //101100101011000100010111
+unsigned int             poly24a = 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 = 0x80006300;   // 1000 0000 0000 0000 0110 0011
+											     // D^24 + D^23 + D^6 + D^5 + D + 1
+unsigned int             poly24c = 0xb2b11700;   // 1011 0010 1011 0001 0001 0111
+												 // D^24+D^23+D^21+D^20+D^17+D^15+D^13+D^12+D^8+D^4+D^2+D+1
 unsigned int             poly16 = 0x10210000;    // 0001 0000 0010 0001            D^16 + D^12 + D^5 + 1
 unsigned int             poly12 = 0x80F00000;    // 1000 0000 1111                 D^12 + D^11 + D^3 + D^2 + D + 1
 unsigned int             poly8 = 0x9B000000;     // 1001 1011                      D^8  + D^7  + D^4 + D^3 + D + 1
@@ -52,10 +55,11 @@ For initialization && verification purposes,
 The first bit is in the MSB of each byte
 
 *********************************************************/
-unsigned int
-crcbit (unsigned char * inputptr, int octetlen, unsigned int poly)
+unsigned int crcbit (unsigned char * inputptr,
+					 int octetlen,
+					 unsigned int poly)
 {
-  unsigned int             i, crc = 0, c;
+  unsigned int i, crc = 0, c;
 
   while (octetlen-- > 0) {
     c = (*inputptr++) << 24;
@@ -78,19 +82,21 @@ crcbit (unsigned char * inputptr, int octetlen, unsigned int poly)
 crc table initialization
 
 *********************************************************/
-static unsigned int      crc24aTable[256];
-static unsigned int      crc24bTable[256];
+static unsigned int        crc24aTable[256];
+static unsigned int        crc24bTable[256];
+static unsigned int        crc24cTable[256];
 static unsigned short      crc16Table[256];
 static unsigned short      crc12Table[256];
 static unsigned char       crc8Table[256];
 
 void crcTableInit (void)
 {
-  unsigned char              c = 0;
+  unsigned char c = 0;
 
   do {
     crc24aTable[c] = crcbit (&c, 1, poly24a);
     crc24bTable[c] = crcbit (&c, 1, poly24b);
+    crc24cTable[c] = crcbit (&c, 1, poly24c);
     crc16Table[c] = (unsigned short) (crcbit (&c, 1, poly16) >> 16);
     crc12Table[c] = (unsigned short) (crcbit (&c, 1, poly12) >> 16);
     crc8Table[c] = (unsigned char) (crcbit (&c, 1, poly8) >> 24);
@@ -114,8 +120,8 @@ Byte by byte implementations,
 assuming initial byte is 0 padded (in MSB) if necessary
 
 *********************************************************/
-unsigned int
-crc24a (unsigned char * inptr, int bitlen)
+unsigned int crc24a (unsigned char * inptr,
+					 int bitlen)
 {
 
   int             octetlen, resbit;
@@ -134,11 +140,11 @@ crc24a (unsigned char * inptr, int bitlen)
   return crc;
 }
 
-unsigned int crc24b (unsigned char * inptr, int bitlen)
+unsigned int crc24b (unsigned char * inptr,
+					 int bitlen)
 {
-
-  int             octetlen, resbit;
-  unsigned int             crc = 0;
+  int octetlen, resbit;
+  unsigned int crc = 0;
   octetlen = bitlen / 8;        /* Change in octets */
   resbit = (bitlen % 8);
 
@@ -153,6 +159,27 @@ unsigned int crc24b (unsigned char * inptr, int bitlen)
   return crc;
 }
 
+unsigned int crc24c (unsigned char * inptr,
+					 int bitlen)
+{
+  int octetlen, resbit;
+  unsigned int crc = 0;
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+/*#ifdef DEBUG_CRC24C
+	  printf("crc24c: in %x => crc %x (%x)\n",crc,*inptr,crc24cTable[(*inptr) ^ (crc >> 24)]);
+#endif*/
+    crc = (crc << 8) ^ crc24cTable[(*inptr++) ^ (crc >> 24)];
+  }
+
+  if (resbit > 0)
+    crc = (crc << resbit) ^ crc24cTable[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))];
+
+  return crc;
+}
+
 unsigned int
 crc16 (unsigned char * inptr, int bitlen)
 {

openair1/PHY/CODING/nrPolar_init.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.1  (the "License"); you may not use this file
- * except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.openairinterface.org/?page_id=698
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *-------------------------------------------------------------------------------
- * For more information about the OpenAirInterface (OAI) Software Alliance:
- *      contact@openairinterface.org
- */
-
-#include "nrPolar_tools/nr_polar_defs.h"
-#include "nrPolar_tools/nr_polar_pbch_defs.h"
-#include "nrPolar_tools/nr_polar_uci_defs.h"
-
-void nr_polar_init(t_nrPolar_params* polarParams, int messageType) {
-
-uint32_t poly6 = 0x84000000; // 1000100000... -> D^6+D^5+1
-uint32_t poly11 = 0x63200000; //11000100001000... -> D^11+D^10+D^9+D^5+1
-uint32_t poly16 = 0x81080000; //100000010000100... - > D^16+D^12+D^5+1
-uint32_t poly24a = 0x864cfb00; //100001100100110011111011 -> 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
-uint32_t poly24b = 0x80006300; //100000000000000001100011 -> D^24+D^23+D^6+D^5+D+1
-uint32_t poly24c = 0xB2B11700; //101100101011000100010111 -> D^24...
-
-	if (messageType == 0) { //DCI
-
-	} else if (messageType == 1) { //PBCH
-		polarParams->n_max = NR_POLAR_PBCH_N_MAX;
-		polarParams->i_il = NR_POLAR_PBCH_I_IL;
-		polarParams->i_seg = NR_POLAR_PBCH_I_SEG;
-		polarParams->n_pc = NR_POLAR_PBCH_N_PC;
-		polarParams->n_pc_wm = NR_POLAR_PBCH_N_PC_WM;
-		polarParams->i_bil = NR_POLAR_PBCH_I_BIL;
-		polarParams->payloadBits = NR_POLAR_PBCH_PAYLOAD_BITS;
-		polarParams->encoderLength = NR_POLAR_PBCH_E;
-		polarParams->crcParityBits = NR_POLAR_PBCH_CRC_PARITY_BITS;
-
-		polarParams->K = polarParams->payloadBits + polarParams->crcParityBits; // Number of bits to encode.
-		polarParams->N = nr_polar_output_length(polarParams->K, polarParams->encoderLength, polarParams->n_max);
-		polarParams->n = log2(polarParams->N);
-
-		polarParams->crc_generator_matrix=crc24c_generator_matrix(polarParams->payloadBits);
-		polarParams->crc_polynomial = poly24c;
-		polarParams->G_N = nr_polar_kronecker_power_matrices(polarParams->n);
-
-		//polar_encoder vectors:
-		polarParams->nr_polar_crc = malloc(sizeof(uint8_t) * polarParams->crcParityBits);
-		polarParams->nr_polar_cPrime = malloc(sizeof(uint8_t) * polarParams->K);
-		polarParams->nr_polar_d = malloc(sizeof(uint8_t) * polarParams->N);
-
-		//Polar Coding vectors
-		polarParams->nr_polar_u = malloc(sizeof(uint8_t) * polarParams->N); //Decoder: nr_polar_uHat
-		polarParams->nr_polar_cPrime = malloc(sizeof(uint8_t) * polarParams->K); //Decoder: nr_polar_cHat
-		polarParams->nr_polar_b = malloc(sizeof(uint8_t) * polarParams->K); //Decoder: nr_polar_bHat
-	} else if (messageType == 2) { //UCI
-		polarParams->payloadBits = NR_POLAR_PUCCH_PAYLOAD_BITS;	//A depends on what they carry...
-		polarParams->encoderLength = NR_POLAR_PUCCH_E ; //E depends on other standards 6.3.1.4
-	
-	        if (polarParams->payloadBits <= 11) //Ref. 38-212, Section 6.3.1.2.2
-			polarParams->crcParityBits = 0; //K=A
-       		else //Ref. 38-212, Section 6.3.1.2.1
-		{
-	 	        if (polarParams->payloadBits < 20)
-                		polarParams->crcParityBits = NR_POLAR_PUCCH_CRC_PARITY_BITS_SHORT;
-            		else
-                		polarParams->crcParityBits =  NR_POLAR_PUCCH_CRC_PARITY_BITS_LONG;
-
-            		if (polarParams->payloadBits >= 360 && polarParams->encoderLength >= 1088)
-		                polarParams->i_seg = NR_POLAR_PUCCH_I_SEG_LONG; // -> C=2
-		        else
-		                polarParams->i_seg = NR_POLAR_PUCCH_I_SEG_SHORT; // -> C=1
-	        }
-
-	        polarParams->K = polarParams->payloadBits + polarParams->crcParityBits; // Number of bits to encode.
-
-	        //K_r = K/C ; C = I_seg+1
-	        if((polarParams->K)/(polarParams->i_seg+1)>=18 && (polarParams->K)/(polarParams->i_seg+1)<=25) //Ref. 38-212, Section 6.3.1.3.1
-	        {
-		        polarParams->n_max = NR_POLAR_PUCCH_N_MAX;
-		        polarParams->i_il =NR_POLAR_PUCCH_I_IL;
-		        polarParams->n_pc = NR_POLAR_PUCCH_N_PC_SHORT;
-
-            		if( (polarParams->encoderLength - polarParams->K)/(polarParams->i_seg + 1) + 3 > 192 )
-		                polarParams->n_pc_wm = NR_POLAR_PUCCH_N_PC_WM_LONG;
-            		else
-		                polarParams->n_pc_wm = NR_POLAR_PUCCH_N_PC_WM_SHORT;
-		}
-
-	        if( (polarParams->K)/(polarParams->i_seg + 1) > 30 ) //Ref. 38-212, Section 6.3.1.3.1
-	        {
-		        polarParams->n_max = NR_POLAR_PUCCH_N_MAX;
-                        polarParams->i_il =NR_POLAR_PUCCH_I_IL;
-		        polarParams->n_pc = NR_POLAR_PUCCH_N_PC_LONG;
-		        polarParams->n_pc_wm = NR_POLAR_PUCCH_N_PC_WM_LONG;
-        	}
-
-	        polarParams->i_bil = NR_POLAR_PUCCH_I_BIL; //Ref. 38-212, Section 6.3.1.4.1
-
-		polarParams->N = nr_polar_output_length(polarParams->K, polarParams->encoderLength, polarParams->n_max);
-		polarParams->n = log2(polarParams->N);
-
-		if((polarParams->payloadBits) <= 19)
-		{
-			polarParams->crc_generator_matrix=crc6_generator_matrix(polarParams->payloadBits);
-			polarParams->crc_polynomial = poly6;
-
-		}
-		else
-		{
-			polarParams->crc_generator_matrix=crc11_generator_matrix(polarParams->payloadBits); 
-			polarParams->crc_polynomial = poly11;
-		}
-		polarParams->G_N = nr_polar_kronecker_power_matrices(polarParams->n);
-
-                //polar_encoder vectors:
-                polarParams->nr_polar_crc = malloc(sizeof(uint8_t) * polarParams->crcParityBits);
-                polarParams->nr_polar_cPrime = malloc(sizeof(uint8_t) * polarParams->K);
-                polarParams->nr_polar_d = malloc(sizeof(uint8_t) * polarParams->N);
-
-                //Polar Coding vectors
-                polarParams->nr_polar_u = malloc(sizeof(uint8_t) * polarParams->N); //Decoder: nr_polar_uHat
-                polarParams->nr_polar_cPrime = malloc(sizeof(uint8_t) * polarParams->K); //Decoder: nr_polar_cHat
-                polarParams->nr_polar_b = malloc(sizeof(uint8_t) * polarParams->K); //Decoder: nr_polar_bHat
-	}
-
-	polarParams->crcCorrectionBits = NR_POLAR_CRC_ERROR_CORRECTION_BITS;
-
-	polarParams->crc256Table = malloc(sizeof(uint32_t)*256);	
-	crcTable256Init(polarParams->crc_polynomial, polarParams->crc256Table);
-	polarParams->Q_0_Nminus1 = nr_polar_sequence_pattern(polarParams->n);
-
-	polarParams->interleaving_pattern = malloc(sizeof(uint16_t) * polarParams->K);
-	nr_polar_interleaving_pattern(polarParams->K, polarParams->i_il, polarParams->interleaving_pattern);
-
-	polarParams->rate_matching_pattern = malloc(sizeof(uint16_t) * polarParams->encoderLength);
-	uint16_t *J = malloc(sizeof(uint16_t) * polarParams->N);
-	nr_polar_rate_matching_pattern(polarParams->rate_matching_pattern, J,
-		nr_polar_subblock_interleaver_pattern, polarParams->K, polarParams->N, polarParams->encoderLength);
-
-
-	polarParams->information_bit_pattern = malloc(sizeof(uint8_t) * polarParams->N);
-	polarParams->Q_I_N = malloc(sizeof(int16_t) * (polarParams->K + polarParams->n_pc));
-	polarParams->Q_F_N = malloc(sizeof(int16_t) * (polarParams->N+1)); // Last element shows the final array index assigned a value.
-	polarParams->Q_PC_N = malloc(sizeof(int16_t) * (polarParams->n_pc));
-	for (int i=0; i<=polarParams->N; i++) polarParams->Q_F_N[i] = -1; // Empty array.
-	nr_polar_info_bit_pattern(polarParams->information_bit_pattern,
-			polarParams->Q_I_N, polarParams->Q_F_N, J, polarParams->Q_0_Nminus1,
-			polarParams->K, polarParams->N, polarParams->encoderLength, polarParams->n_pc);
-
-	polarParams->channel_interleaver_pattern = malloc(sizeof(uint16_t) * polarParams->encoderLength);
-	nr_polar_channel_interleaver_pattern(polarParams->channel_interleaver_pattern,
-			polarParams->i_bil, polarParams->encoderLength);
-
-	free(J);
-}

openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c

@@ -21,17 +21,38 @@
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
-void nr_byte2bit(uint8_t *array, uint8_t arraySize, uint8_t *bitArray){//First 2 parameters are in bytes.
+void nr_bit2byte_uint32_8_t(uint32_t *in, uint16_t arraySize, uint8_t *out) {
+	uint8_t arrayInd = ceil(arraySize / 32.0);
+	for (int i = 0; i < (arrayInd-1); i++) {
+		for (int j = 0; j < 32; j++) {
+			out[j+(i*32)] = (in[i] >> j) & 1;
+		}
+	}
+
+	for (int j = 0; j < arraySize - ((arrayInd-1) * 32); j++) out[j + ((arrayInd-1) * 32)] = (in[(arrayInd-1)] >> j) & 1;
+}
 
-	for (int i=0; i<arraySize; i++){
-		bitArray[(7+(i*8))] = ( array[i]>>0 & 0x01);
-		bitArray[(6+(i*8))] = ( array[i]>>1 & 0x01);
-		bitArray[(5+(i*8))] = ( array[i]>>2 & 0x01);
-		bitArray[(4+(i*8))] = ( array[i]>>3 & 0x01);
-		bitArray[(3+(i*8))] = ( array[i]>>4 & 0x01);
-		bitArray[(2+(i*8))] = ( array[i]>>5 & 0x01);
-		bitArray[(1+(i*8))] = ( array[i]>>6 & 0x01);
-		bitArray[  (i*8)  ] = ( array[i]>>7 & 0x01);
+void nr_byte2bit_uint8_32_t(uint8_t *in, uint16_t arraySize, uint32_t *out) {
+	uint8_t arrayInd = ceil(arraySize / 32.0);
+	for (int i = 0; i < arrayInd; i++) {
+		out[i]=0;
+		for (int j = 31; j > 0; j--) {
+			out[i]|=in[(i*32)+j];
+			out[i]<<=1;
+		}
+		out[i]|=in[(i*32)];
 	}
+}
 
+void nr_crc_bit2bit_uint32_8_t(uint32_t *in, uint16_t arraySize, uint8_t *out) {
+	out[0]=0xff;
+	out[1]=0xff;
+	out[2]=0xff;
+	uint8_t arrayInd = ceil(arraySize / 32.0);
+	for (int i = 0; i < arrayInd; i++) {
+		out[3+i*4] = ((in[i] & (0x0000000f))<<4) | ((in[i] & (0x000000f0))>>4);
+		out[4+i*4] = (((in[i] & (0x00000f00))<<4) | ((in[i] & (0x0000f000))>>4))>>8;
+		out[5+i*4] = (((in[i] & (0x000f0000))<<4) | ((in[i] & (0x00f00000))>>4))>>16;
+		out[6+i*4] = (((in[i] & (0x0f000000))<<4) | ((in[i] & (0xf0000000))>>4))>>24;
+	}
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_channel_interleaver_pattern.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.1  (the "License"); you may not use this file
- * except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.openairinterface.org/?page_id=698
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *-------------------------------------------------------------------------------
- * For more information about the OpenAirInterface (OAI) Software Alliance:
- *      contact@openairinterface.org
- */
-
-#include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
-
-void nr_polar_channel_interleaver_pattern(uint16_t *cip, uint8_t I_BIL, uint16_t E){
-	
-	if (I_BIL == 1) {
-		uint16_t T=0, k;
-		while( ((T/2)*(T+1)) < E ) T++;
-		
-		
-		int16_t **v = malloc(T * sizeof(*v));
-		for (int i = 0; i <= T-1; i++) v[i] = malloc((T-i) * sizeof(*(v[i])));
-		
-		k=0;
-		for (int i = 0; i <= T-1; i++) {
-			for (int j = 0; j <= (T-1)-i; j++) {
-				if (k<E) {
-					v[i][j] = k;
-				} else {
-					v[i][j] = (-1);
-				}
-				k++;					
-			}
-		}
-		
-		k=0;
-		for (int j = 0; j <= T-1; j++) {
-					for (int i = 0; i <= (T-1)-j; i++) {
-						if ( v[i][j] != (-1) ) {
-							cip[k]=v[i][j];
-							k++;
-						}
-					}
-				}
-		
-		for (int i = 0; i <= T-1; i++) free(v[i]);
-		free(v);
-		
-	} else {
-		for (int i=0; i<=E-1; i++) cip[i]=i;
-	}
-	
-}

openair1/PHY/CODING/nrPolar_tools/nr_polar_dci_defs.h

@@ -33,10 +33,14 @@
 #ifndef __NR_POLAR_DCI_DEFS__H__
 #define __NR_POLAR_DCI_DEFS__H__
 
+#define NR_POLAR_DCI_MESSAGE_TYPE 1 //int8_t
+#define NR_POLAR_DCI_CRC_PARITY_BITS 24
+#define NR_POLAR_DCI_CRC_ERROR_CORRECTION_BITS 3
+
 //Sec. 7.3.3: Channel Coding
 #define NR_POLAR_DCI_N_MAX 9   //uint8_t
 #define NR_POLAR_DCI_I_IL 1    //uint8_t
-//#define NR_POLAR_DCI_I_SEG 0   //uint8_t
+#define NR_POLAR_DCI_I_SEG 0   //uint8_t
 #define NR_POLAR_DCI_N_PC 0    //uint8_t
 #define NR_POLAR_DCI_N_PC_WM 0 //uint8_t
 

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c

@@ -19,10 +19,30 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
-void updateLLR(double ***llr, uint8_t **llrU, uint8_t ***bit, uint8_t **bitU,
-		uint8_t listSize, uint16_t row, uint16_t col, uint16_t xlen, uint8_t ylen, uint8_t approximation) {
+void updateLLR(double ***llr,
+			   uint8_t **llrU,
+			   uint8_t ***bit,
+			   uint8_t **bitU,
+			   uint8_t listSize,
+			   uint16_t row,
+			   uint16_t col,
+			   uint16_t xlen,
+			   uint8_t ylen,
+			   uint8_t approximation)
+{
 	uint16_t offset = (xlen/(pow(2,(ylen-col-1))));
 	for (uint8_t i=0; i<listSize; i++) {
 		if (( (row) % (2*offset) ) >= offset ) {
@@ -40,8 +60,14 @@ void updateLLR(double ***llr, uint8_t **llrU, uint8_t ***bit, uint8_t **bitU,
 	llrU[row][col]=1;
 }
 
-void updateBit(uint8_t ***bit, uint8_t **bitU, uint8_t listSize, uint16_t row,
-		uint16_t col, uint16_t xlen, uint8_t ylen) {
+void updateBit(uint8_t ***bit,
+			   uint8_t **bitU,
+			   uint8_t listSize,
+			   uint16_t row,
+			   uint16_t col,
+			   uint16_t xlen,
+			   uint8_t ylen)
+{
 	uint16_t offset = ( xlen/(pow(2,(ylen-col))) );
 
 	for (uint8_t i=0; i<listSize; i++) {
@@ -58,9 +84,13 @@ void updateBit(uint8_t ***bit, uint8_t **bitU, uint8_t listSize, uint16_t row,
 	bitU[row][col]=1;
 }
 
-void updatePathMetric(double *pathMetric, double ***llr, uint8_t listSize, uint8_t bitValue,
-		uint16_t row, uint8_t approximation) {
-
+void updatePathMetric(double *pathMetric,
+					  double ***llr,
+					  uint8_t listSize,
+					  uint8_t bitValue,
+					  uint16_t row,
+					  uint8_t approximation)
+{
 	if (approximation) { //eq. (12)
 		for (uint8_t i=0; i<listSize; i++) {
 			if ((2*bitValue) != ( 1 - copysign(1.0,llr[row][0][i]) )) pathMetric[i] += fabs(llr[row][0][i]);
@@ -69,11 +99,14 @@ void updatePathMetric(double *pathMetric, double ***llr, uint8_t listSize, uint8
 		int8_t multiplier = (2*bitValue) - 1;
 		for (uint8_t i=0; i<listSize; i++) pathMetric[i] += log ( 1 + exp(multiplier*llr[row][0][i]) ) ;
 	}
-
 }
 
-void updatePathMetric2(double *pathMetric, double ***llr, uint8_t listSize, uint16_t row, uint8_t appr) {
-
+void updatePathMetric2(double *pathMetric,
+					   double ***llr,
+					   uint8_t listSize,
+					   uint16_t row,
+					   uint8_t appr)
+{
 	double *tempPM = malloc(sizeof(double) * listSize);
 	for (int i=0; i < listSize; i++) tempPM[i]=pathMetric[i];
 
@@ -101,9 +134,13 @@ void updatePathMetric2(double *pathMetric, double ***llr, uint8_t listSize, uint
 
 }
 
-void computeLLR(double ***llr, uint16_t row, uint16_t col, uint8_t i,
-		uint16_t offset, uint8_t approximation) {
-
+void computeLLR(double ***llr,
+				uint16_t row,
+				uint16_t col,
+				uint8_t i,
+				uint16_t offset,
+				uint8_t approximation)
+{
 	double a = llr[row][col + 1][i];
 	double absA = fabs(a);
 	double b = llr[row + offset][col + 1][i];
@@ -117,8 +154,12 @@ void computeLLR(double ***llr, uint16_t row, uint16_t col, uint8_t i,
 
 }
 
-void updateCrcChecksum(uint8_t **crcChecksum, uint8_t **crcGen,
-		uint8_t listSize, uint32_t i2, uint8_t len) {
+void updateCrcChecksum(uint8_t **crcChecksum,
+					   uint8_t **crcGen,
+					   uint8_t listSize,
+					   uint32_t i2,
+					   uint8_t len)
+{
 	for (uint8_t i = 0; i < listSize; i++) {
 		for (uint8_t j = 0; j < len; j++) {
 			crcChecksum[j][i] = ( (crcChecksum[j][i] + crcGen[i2][j]) % 2 );
@@ -126,8 +167,12 @@ void updateCrcChecksum(uint8_t **crcChecksum, uint8_t **crcGen,
 	}
 }
 
-void updateCrcChecksum2(uint8_t **crcChecksum, uint8_t **crcGen,
-		uint8_t listSize, uint32_t i2, uint8_t len) {
+void updateCrcChecksum2(uint8_t **crcChecksum,
+						uint8_t **crcGen,
+						uint8_t listSize,
+						uint32_t i2,
+						uint8_t len)
+{
 	for (uint8_t i = 0; i < listSize; i++) {
 		for (uint8_t j = 0; j < len; j++) {
 			crcChecksum[j][i+listSize] = ( (crcChecksum[j][i] + crcGen[i2][j]) % 2 );

openair1/PHY/CODING/nrPolar_tools/nr_polar_interleaving_pattern.c

@@ -19,6 +19,17 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_interleaving_pattern.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
 void nr_polar_interleaving_pattern(uint16_t K, uint8_t I_IL, uint16_t *PI_k_){

openair1/PHY/CODING/nrPolar_tools/nr_polar_kronecker_power_matrices.c

@@ -19,6 +19,17 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_kronecker_power_matrices.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
 uint8_t (*const(G_N_1[])) = {

openair1/PHY/CODING/nrPolar_tools/nr_polar_matrix_and_array.c

@@ -19,6 +19,17 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_matrix_and_array.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
 void nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(uint8_t *matrix1, uint8_t **matrix2,

openair1/PHY/CODING/nrPolar_tools/nr_polar_output_length.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.1  (the "License"); you may not use this file
- * except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.openairinterface.org/?page_id=698
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *-------------------------------------------------------------------------------
- * For more information about the OpenAirInterface (OAI) Software Alliance:
- *      contact@openairinterface.org
- */
-
-#include <math.h>
-#include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
-
-uint32_t nr_polar_output_length(uint16_t K, uint16_t E, uint8_t n_max){
-	uint8_t n_1, n_2, n_min=5, n;
-	uint32_t polar_code_output_length;
-	double R_min=1.0/8;
-	
-	if ( (E <= (9.0/8)*pow(2,ceil(log2(E))-1)) && (K/E < 9.0/16) ) {
-		n_1 = ceil(log2(E))-1;		
-	} else {
-		n_1 = ceil(log2(E));
-	}
-	
-	n_2 = ceil(log2(K/R_min));
-	
-	n=n_max;
-	if (n>n_1) n=n_1;
-	if (n>n_2) n=n_2;
-	if (n<n_min) n=n_min;
-	
-	polar_code_output_length = (uint32_t) pow(2.0,n);
-	
-	return polar_code_output_length;
-}

openair1/PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h

@@ -19,21 +19,23 @@
  *      contact@openairinterface.org
  */
 
-/*! \file PHY/CODING/nrPolar_tools/nr_polar_dci_defs.h
-* \brief Defines the constant variables for polar coding of the PBCH from 38-212, V15.1.1 2018-04.
-* \author
-* \date 2018
-* \version 0.1
-* \company Eurecom
-* \email:
-* \note
-* \warning
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h
+ * \brief Defines the constant variables for polar coding of the PBCH from 38-212, V15.1.1 2018-04.
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
 */
 
 #ifndef __NR_POLAR_PBCH_DEFS__H__
 #define __NR_POLAR_PBCH_DEFS__H__
 
-#define NR_POLAR_PBCH_PAYLOAD_BITS 32 //uint16_t
+#define NR_POLAR_PBCH_AGGREGATION_LEVEL 0 //uint8_t
+#define NR_POLAR_PBCH_MESSAGE_TYPE 0      //int8_t
+#define NR_POLAR_PBCH_PAYLOAD_BITS 32     //uint16_t
 #define NR_POLAR_PBCH_CRC_PARITY_BITS 24
 #define NR_POLAR_PBCH_CRC_ERROR_CORRECTION_BITS 3
 //Assumed 3 by 3GPP when NR_POLAR_PBCH_L>8 to meet false alarm rate requirements.
@@ -49,9 +51,7 @@
 //Sec. 7.1.5: Rate Matching
 #define NR_POLAR_PBCH_I_BIL 0 //uint8_t
 #define NR_POLAR_PBCH_E 864   //uint16_t
-
-//#define NR_POLAR_PBCH_L 5 //uint8_t
-#define NR_POLAR_PBCH_PATH_METRIC_APPROXIMATION 0 //uint8_t; 0 --> eq. (8a) and (11b), 1 --> eq. (9) and (12)
+#define NR_POLAR_PBCH_E_DWORD 27 // NR_POLAR_PBCH_E/32
 
 /*
  * TEST CODE

openair1/PHY/CODING/nrPolar_tools/nr_polar_info_bit_pattern.c → openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c

@@ -19,12 +19,132 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_procedures.h
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
-void nr_polar_info_bit_pattern(uint8_t *ibp, int16_t *Q_I_N, int16_t *Q_F_N,
-		uint16_t *J, const uint16_t *Q_0_Nminus1, uint16_t K, uint16_t N, uint16_t E,
-		uint8_t n_PC) {
+void nr_polar_bit_insertion(uint8_t *input,
+						    uint8_t *output,
+							uint16_t N,
+							uint16_t K,
+							int16_t *Q_I_N,
+							int16_t *Q_PC_N,
+							uint8_t n_PC)
+{
+	uint16_t k=0;
+	uint8_t flag;
+
+	if (n_PC>0) {
+		/*
+		 *
+		 */
+	} else {
+		for (int n=0; n<=N-1; n++) {
+			flag=0;
+			for (int m=0; m<=(K+n_PC)-1; m++) {
+				if ( n == Q_I_N[m]) {
+					flag=1;
+					break;
+				}
+			}
+			if (flag) { // n ϵ Q_I_N
+				output[n]=input[k];
+				k++;
+			} else {
+				output[n] = 0;
+			}
+		}
+	}
+
+}
+
+
+uint32_t nr_polar_output_length(uint16_t K,
+								uint16_t E,
+								uint8_t n_max)
+{
+	uint8_t n_1, n_2, n_min=5, n;
+	double R_min=1.0/8;
+
+	if ( (E <= (9.0/8)*pow(2,ceil(log2(E))-1)) && (K/E < 9.0/16) ) {
+		n_1 = ceil(log2(E))-1;
+	} else {
+		n_1 = ceil(log2(E));
+	}
+
+	n_2 = ceil(log2(K/R_min));
+
+	n=n_max;
+	if (n>n_1) n=n_1;
+	if (n>n_2) n=n_2;
+	if (n<n_min) n=n_min;
+
+	return ((uint32_t) pow(2.0,n)); //=polar_code_output_length
+}
+
+
+void nr_polar_channel_interleaver_pattern(uint16_t *cip,
+										  uint8_t I_BIL,
+										  uint16_t E)
+{
+	if (I_BIL == 1) {
+		uint16_t T=0, k;
+		while( ((T/2)*(T+1)) < E ) T++;
+
+		int16_t **v = malloc(T * sizeof(*v));
+		for (int i = 0; i <= T-1; i++) v[i] = malloc((T-i) * sizeof(*(v[i])));
+
+		k=0;
+		for (int i = 0; i <= T-1; i++) {
+			for (int j = 0; j <= (T-1)-i; j++) {
+				if (k<E) {
+					v[i][j] = k;
+				} else {
+					v[i][j] = (-1);
+				}
+				k++;
+			}
+		}
+
+		k=0;
+		for (int j = 0; j <= T-1; j++) {
+					for (int i = 0; i <= (T-1)-j; i++) {
+						if ( v[i][j] != (-1) ) {
+							cip[k]=v[i][j];
+							k++;
+						}
+					}
+				}
+
+		for (int i = 0; i <= T-1; i++) free(v[i]);
+		free(v);
+
+	} else {
+		for (int i=0; i<=E-1; i++) cip[i]=i;
+	}
 
+}
+
+
+void nr_polar_info_bit_pattern(uint8_t *ibp,
+							   int16_t *Q_I_N,
+							   int16_t *Q_F_N,
+							   uint16_t *J,
+							   const uint16_t *Q_0_Nminus1,
+							   uint16_t K,
+							   uint16_t N,
+							   uint16_t E,
+							   uint8_t n_PC)
+{
 	int16_t *Q_Ftmp_N = malloc(sizeof(int16_t) * (N + 1)); // Last element shows the final
 	int16_t *Q_Itmp_N = malloc(sizeof(int16_t) * (N + 1)); // array index assigned a value.
 
@@ -120,7 +240,12 @@ void nr_polar_info_bit_pattern(uint8_t *ibp, int16_t *Q_I_N, int16_t *Q_F_N,
 	free(Q_Itmp_N);
 }
 
-void nr_polar_info_bit_extraction(uint8_t *input, uint8_t *output, uint8_t *pattern, uint16_t size) {
+
+void nr_polar_info_bit_extraction(uint8_t *input,
+								  uint8_t *output,
+								  uint8_t *pattern,
+								  uint16_t size)
+{
 	uint16_t j = 0;
 	for (int i = 0; i < size; i++) {
 		if (pattern[i] > 0) {
@@ -129,3 +254,62 @@ void nr_polar_info_bit_extraction(uint8_t *input, uint8_t *output, uint8_t *patt
 		}
 	}
 }
+
+
+void nr_polar_rate_matching_pattern(uint16_t *rmp, uint16_t *J, const uint8_t *P_i_, uint16_t K, uint16_t N, uint16_t E){
+
+	uint8_t i;
+	uint16_t *d, *y, ind;
+	d = (uint16_t *)malloc(sizeof(uint16_t) * N);
+	y = (uint16_t *)malloc(sizeof(uint16_t) * N);
+
+	for (int m=0; m<=N-1; m++) d[m]=m;
+
+	for (int m=0; m<=N-1; m++){
+		i=floor((32*m)/N);
+		J[m] = (P_i_[i]*(N/32)) + (m%(N/32));
+		y[m] = d[J[m]];
+	}
+
+	if (E>=N) { //repetition
+		for (int k=0; k<=E-1; k++) {
+			ind = (k%N);
+			rmp[k]=y[ind];
+		}
+	} else {
+		if ( (K/(double)E) <= (7.0/16) ) { //puncturing
+			for (int k=0; k<=E-1; k++) {
+				rmp[k]=y[k+N-E];
+			}
+		} else { //shortening
+			for (int k=0; k<=E-1; k++) {
+				rmp[k]=y[k];
+			}
+		}
+	}
+
+	free(d);
+	free(y);
+}
+
+
+void nr_polar_rate_matching(double *input, double *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E){
+
+	if (E>=N) { //repetition
+		for (int i=0; i<=N-1; i++) output[i]=0;
+		for (int i=0; i<=E-1; i++){
+			output[rmp[i]]+=input[i];
+		}
+	} else {
+		if ( (K/(double)E) <= (7.0/16) ) { //puncturing
+			for (int i=0; i<=N-1; i++) output[i]=0;
+		} else { //shortening
+			for (int i=0; i<=N-1; i++) output[i]=INFINITY;
+		}
+
+		for (int i=0; i<=E-1; i++){
+			output[rmp[i]]=input[i];
+		}
+	}
+
+}

openair1/PHY/CODING/nrPolar_tools/nr_polar_rate_match.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.1  (the "License"); you may not use this file
- * except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.openairinterface.org/?page_id=698
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *-------------------------------------------------------------------------------
- * For more information about the OpenAirInterface (OAI) Software Alliance:
- *      contact@openairinterface.org
- */
-
-#include <math.h>
-#include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
-
-void nr_polar_rate_matching_pattern(uint16_t *rmp, uint16_t *J, const uint8_t *P_i_, uint16_t K, uint16_t N, uint16_t E){
-	
-	uint8_t i;
-	uint16_t *d, *y, ind;
-	d = (uint16_t *)malloc(sizeof(uint16_t) * N);
-	y = (uint16_t *)malloc(sizeof(uint16_t) * N);
-	
-	for (int m=0; m<=N-1; m++) d[m]=m;
-	
-	for (int m=0; m<=N-1; m++){
-		i=floor((32*m)/N);
-		J[m] = (P_i_[i]*(N/32)) + (m%(N/32));
-		y[m] = d[J[m]];
-	}
-	
-	if (E>=N) { //repetition
-		for (int k=0; k<=E-1; k++) {
-			ind = (k%N);
-			rmp[k]=y[ind];
-		}
-	} else {
-		if ( (K/(double)E) <= (7.0/16) ) { //puncturing
-			for (int k=0; k<=E-1; k++) {
-				rmp[k]=y[k+N-E];
-			}
-		} else { //shortening
-			for (int k=0; k<=E-1; k++) {
-				rmp[k]=y[k];
-			}
-		}	
-	}	
-	
-	free(d);
-	free(y);
-}
-
-
-void nr_polar_rate_matching(double *input, double *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E){
-
-	if (E>=N) { //repetition
-		for (int i=0; i<=N-1; i++) output[i]=0;
-		for (int i=0; i<=E-1; i++){
-			output[rmp[i]]+=input[i];
-		}
-	} else {
-		if ( (K/(double)E) <= (7.0/16) ) { //puncturing
-			for (int i=0; i<=N-1; i++) output[i]=0;
-		} else { //shortening
-			for (int i=0; i<=N-1; i++) output[i]=INFINITY;
-		}
-
-		for (int i=0; i<=E-1; i++){
-			output[rmp[i]]=input[i];
-		}
-	}
-
-}

openair1/PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h

@@ -33,27 +33,7 @@
 #ifndef __NR_POLAR_UCI_DEFS__H__
 #define __NR_POLAR_UCI_DEFS__H__
 
-#define NR_POLAR_PUCCH_PAYLOAD_BITS 32
-#define NR_POLAR_PUCCH_E 32
-
-//Ref. 38-212, Section 6.3.1.2.1
-#define NR_POLAR_PUCCH_CRC_PARITY_BITS_SHORT 6
-#define NR_POLAR_PUCCH_CRC_PARITY_BITS_LONG 11
-
-#define NR_POLAR_PUCCH_I_SEG_LONG 1
-#define NR_POLAR_PUCCH_I_SEG_SHORT 0
-
-//Ref. 38-212, Section 6.3.1.3.1
-#define NR_POLAR_PUCCH_N_MAX 10
-#define NR_POLAR_PUCCH_I_IL 0
-#define NR_POLAR_PUCCH_N_PC_SHORT 3
-#define NR_POLAR_PUCCH_N_PC_LONG 0
-#define NR_POLAR_PUCCH_N_PC_WM_LONG 0
-#define NR_POLAR_PUCCH_N_PC_WM_SHORT 1
-
-//Ref. 38-212, Section 6.3.1.4.1
-#define NR_POLAR_PUCCH_I_BIL 1
-
-
+#define NR_POLAR_UCI_MESSAGE_TYPE -1 //int8_t
+#define NR_POLAR_UCI_CRC_ERROR_CORRECTION_BITS 3
 
 #endif

openair1/PHY/CODING/nr_compute_tbs.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.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/* file: nr_compute_tbs.c
+   purpose: Compute NR TBS
+   author: Hongzhi WANG (TCL)
+*/
+#include "PHY/defs_nr_UE.h"
+//#include "SCHED/extern.h"
+
+#define INDEX_MAX_TBS_TABLE (93)
+//Table 5.1.3.1-1
+uint16_t Mcsindextable1[29][3] = {{2,120,0.2344},
+           	   	   	   	   	   	 {2,157,0.3066},
+								 {2,193,0.3770},
+								 {2,251,0.4902},
+								 {2,308,0.6016},
+								 {2,379,0.7402},
+								 {2,449,0.8770},
+								 {2,526,1.0273},
+								 {2,602,1.1758},
+								 {2,679,1.3262},
+								 {4,340,1.3281},
+								 {4,378,1.4766},
+								 {4,434,1.6953},
+								 {4,490,1.9141},
+								 {4,553,2.1602},
+								 {4,616,2.4063},
+								 {4,658,2.5703},
+								 {6,438,2.5664},
+								 {6,466,2.7305},
+								 {6,517,3.0293},
+								 {6,567,3.3223},
+								 {6,616,3.6094},
+								 {6,666,3.9023},
+								 {6,719,4.2129},
+								 {6,772,4.5234},
+								 {6,822,4.8164},
+								 {6,873,5.1152},
+								 {6,910,5.3320},
+								 {6,948,5.5547}};
+//Table 5.1.2.2-2
+uint16_t Tbstable_nr[INDEX_MAX_TBS_TABLE] = {24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160,168,176,184,192,208,224,240,256,272,288,304,320,336,352,368,384,408,432,456,480,504,528,552,576,608,640,672,704,736,768,808,848,888,928,984,1032,1064,1128,1160,1192,1224,1256,1288,1320,1352,1416,1480,1544,1608,1672,1736,1800,1864,1928,2024,2088,2152,2216,2280,2408,2472,2536,2600,2664,2728,2792,2856,2976,3104,3240,3368,3496,3624,3752,3824};
+
+uint32_t nr_compute_tbs(uint8_t mcs,
+						uint16_t nb_rb,
+						uint16_t nb_symb_sch,
+						uint8_t nb_re_dmrs,
+						uint16_t length_dmrs,
+						uint8_t Nl)
+{
+	uint16_t nbp_re, nb_re, nb_dmrs_prb, nb_rb_oh, Ninfo,Np_info,n,Qm,R,C;
+	uint32_t nr_tbs;
+
+	nb_rb_oh = 0; //set to 0 if not configured by higher layer
+	Qm = Mcsindextable1[mcs][0];
+	R  = Mcsindextable1[mcs][1];
+	nb_dmrs_prb = nb_re_dmrs*length_dmrs;
+
+	nbp_re = 12 * nb_symb_sch - nb_dmrs_prb - nb_rb_oh;
+
+	nb_re = min(156, nbp_re) * nb_rb;
+
+    // Intermediate number of information bits
+    Ninfo = (nb_re * R * Qm * Nl)/1024;
+
+    //printf("Ninfo %d nbp_re %d nb_re %d Qm %d, R %d\n", Ninfo, nbp_re, nb_re, Qm, R);
+
+    if (Ninfo <=3824) {
+
+    	n = max(3, floor(log2(Ninfo)) - 6);
+        Np_info = max(24, pow(n,2) * floor(Ninfo/pow(n,2)));
+
+        for (int i=0; i<INDEX_MAX_TBS_TABLE; i++) {
+        	if (Tbstable_nr[i] >= Np_info){
+        		nr_tbs = Tbstable_nr[i];
+        		break;
+        	}
+        }
+    }
+    else {
+    	n = floor(log2(Ninfo-24)) - 5;
+        Np_info = max(3840, pow(n,2) * round((Ninfo - 24)/pow(n,2)));
+
+        if (R <= 1024/4) {
+            C = ceil( (Np_info + 24)/3816 );
+            nr_tbs = 8 * C * ceil( (Np_info + 24)/(8*C) ) - 24;
+        }
+        else {
+            if (Np_info > 8424){
+                C = ceil( (Np_info + 24)/8424 );
+                nr_tbs = 8 * C * ceil( (Np_info + 24)/(8*C) ) - 24;
+            }
+            else
+            	nr_tbs = 8 * ceil( (Np_info + 24)/8 ) - 24;
+
+        }
+
+    }
+
+	return nr_tbs;
+}

openair1/PHY/CODING/nr_polar_init.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.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*!\file PHY/CODING/nr_polar_init.h
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
+#include "nrPolar_tools/nr_polar_defs.h"
+#include "PHY/CODING/nrPolar_tools/nr_polar_dci_defs.h"
+#include "PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h"
+#include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h"
+#include "PHY/NR_TRANSPORT/nr_dci.h"
+
+void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
+				   int8_t messageType,
+				   uint16_t messageLength,
+				   uint8_t aggregation_level)
+{
+	t_nrPolar_paramsPtr currentPtr = *polarParams;
+	uint16_t aggregation_prime = nr_polar_aggregation_prime(aggregation_level);
+
+	//Parse the list. If the node is already created, return without initialization.
+	while (currentPtr != NULL) {
+		if (currentPtr->idx == (messageType * messageLength * aggregation_prime)) return;
+		else currentPtr = currentPtr->nextPtr;
+	}
+
+	//Else, initialize and add node to the end of the linked list.
+	t_nrPolar_paramsPtr newPolarInitNode = malloc(sizeof(t_nrPolar_params));
+
+	if (newPolarInitNode != NULL) {
+
+		newPolarInitNode->idx = (messageType * messageLength * aggregation_prime);
+		newPolarInitNode->nextPtr = NULL;
+
+		if (messageType == 0) { //PBCH
+			newPolarInitNode->n_max = NR_POLAR_PBCH_N_MAX;
+			newPolarInitNode->i_il = NR_POLAR_PBCH_I_IL;
+			newPolarInitNode->i_seg = NR_POLAR_PBCH_I_SEG;
+			newPolarInitNode->n_pc = NR_POLAR_PBCH_N_PC;
+			newPolarInitNode->n_pc_wm = NR_POLAR_PBCH_N_PC_WM;
+			newPolarInitNode->i_bil = NR_POLAR_PBCH_I_BIL;
+			newPolarInitNode->crcParityBits = NR_POLAR_PBCH_CRC_PARITY_BITS;
+			newPolarInitNode->payloadBits = NR_POLAR_PBCH_PAYLOAD_BITS;
+			newPolarInitNode->encoderLength = NR_POLAR_PBCH_E;
+			newPolarInitNode->crcCorrectionBits = NR_POLAR_PBCH_CRC_ERROR_CORRECTION_BITS;
+			newPolarInitNode->crc_generator_matrix = crc24c_generator_matrix(newPolarInitNode->payloadBits);//G_P
+		} else if (messageType == 1) { //DCI
+			newPolarInitNode->n_max = NR_POLAR_DCI_N_MAX;
+			newPolarInitNode->i_il = NR_POLAR_DCI_I_IL;
+			newPolarInitNode->i_seg = NR_POLAR_DCI_I_SEG;
+			newPolarInitNode->n_pc = NR_POLAR_DCI_N_PC;
+			newPolarInitNode->n_pc_wm = NR_POLAR_DCI_N_PC_WM;
+			newPolarInitNode->i_bil = NR_POLAR_DCI_I_BIL;
+			newPolarInitNode->crcParityBits = NR_POLAR_DCI_CRC_PARITY_BITS;
+			newPolarInitNode->payloadBits = messageLength;
+			newPolarInitNode->encoderLength = aggregation_level*108;
+			newPolarInitNode->crcCorrectionBits = NR_POLAR_DCI_CRC_ERROR_CORRECTION_BITS;
+			newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P
+		} else if (messageType == -1) { //UCI
+
+		} else {
+			AssertFatal(1 == 0, "[nr_polar_init] Incorrect Message Type(%d)", messageType);
+		}
+
+		newPolarInitNode->K = newPolarInitNode->payloadBits + newPolarInitNode->crcParityBits; // Number of bits to encode.
+		newPolarInitNode->N = nr_polar_output_length(newPolarInitNode->K, newPolarInitNode->encoderLength, newPolarInitNode->n_max);
+		newPolarInitNode->n = log2(newPolarInitNode->N);
+		newPolarInitNode->G_N = nr_polar_kronecker_power_matrices(newPolarInitNode->n);
+
+		//polar_encoder vectors:
+		newPolarInitNode->nr_polar_crc = malloc(sizeof(uint8_t) * newPolarInitNode->crcParityBits);
+		newPolarInitNode->nr_polar_aPrime = malloc(sizeof(uint8_t) * ((ceil((newPolarInitNode->payloadBits)/32.0)*4)+3));
+		newPolarInitNode->nr_polar_APrime = malloc(sizeof(uint8_t) * newPolarInitNode->K);
+		newPolarInitNode->nr_polar_D = malloc(sizeof(uint8_t) * newPolarInitNode->N);
+		newPolarInitNode->nr_polar_E = malloc(sizeof(uint8_t) * newPolarInitNode->encoderLength);
+
+		//Polar Coding vectors
+		newPolarInitNode->nr_polar_U = malloc(sizeof(uint8_t) * newPolarInitNode->N); //Decoder: nr_polar_uHat
+		newPolarInitNode->nr_polar_CPrime = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_cHat
+		newPolarInitNode->nr_polar_B = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_bHat
+		newPolarInitNode->nr_polar_A = malloc(sizeof(uint8_t) * newPolarInitNode->payloadBits); //Decoder: nr_polar_aHat
+
+
+
+		newPolarInitNode->Q_0_Nminus1 = nr_polar_sequence_pattern(newPolarInitNode->n);
+
+		newPolarInitNode->interleaving_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->K);
+		nr_polar_interleaving_pattern(newPolarInitNode->K,
+									  newPolarInitNode->i_il,
+									  newPolarInitNode->interleaving_pattern);
+
+		newPolarInitNode->rate_matching_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
+		uint16_t *J = malloc(sizeof(uint16_t) * newPolarInitNode->N);
+		nr_polar_rate_matching_pattern(newPolarInitNode->rate_matching_pattern,
+									   J,
+									   nr_polar_subblock_interleaver_pattern,
+									   newPolarInitNode->K,
+									   newPolarInitNode->N,
+									   newPolarInitNode->encoderLength);
+
+		newPolarInitNode->information_bit_pattern = malloc(sizeof(uint8_t) * newPolarInitNode->N);
+		newPolarInitNode->Q_I_N = malloc(sizeof(int16_t) * (newPolarInitNode->K + newPolarInitNode->n_pc));
+		newPolarInitNode->Q_F_N = malloc( sizeof(int16_t) * (newPolarInitNode->N + 1)); // Last element shows the final array index assigned a value.
+		newPolarInitNode->Q_PC_N = malloc( sizeof(int16_t) * (newPolarInitNode->n_pc));
+		for (int i = 0; i <= newPolarInitNode->N; i++)
+			newPolarInitNode->Q_F_N[i] = -1; // Empty array.
+		nr_polar_info_bit_pattern(newPolarInitNode->information_bit_pattern,
+								  newPolarInitNode->Q_I_N,
+								  newPolarInitNode->Q_F_N,
+								  J,
+								  newPolarInitNode->Q_0_Nminus1,
+								  newPolarInitNode->K,
+								  newPolarInitNode->N,
+								  newPolarInitNode->encoderLength,
+								  newPolarInitNode->n_pc);
+
+		newPolarInitNode->channel_interleaver_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
+		nr_polar_channel_interleaver_pattern(newPolarInitNode->channel_interleaver_pattern,
+											 newPolarInitNode->i_bil,
+											 newPolarInitNode->encoderLength);
+
+		free(J);
+
+	} else {
+		AssertFatal(1 == 0, "[nr_polar_init] New t_nrPolar_paramsPtr could not be created");
+	}
+
+	currentPtr = *polarParams;
+	//If polarParams is empty:
+	if (currentPtr == NULL)
+	{
+		*polarParams = newPolarInitNode;
+		return;
+	}
+	//Else, add node to the end of the linked list.
+	while (currentPtr->nextPtr != NULL) {
+			currentPtr = currentPtr->nextPtr;
+	}
+	currentPtr->nextPtr= newPolarInitNode;
+	return;
+}
+
+void nr_polar_print_polarParams(t_nrPolar_paramsPtr polarParams)
+{
+	uint8_t i = 0;
+	if (polarParams == NULL) {
+		printf("polarParams is empty.\n");
+	} else {
+		while (polarParams != NULL){
+			printf("polarParams[%d] = %d\n", i, polarParams->idx);
+			polarParams = polarParams->nextPtr;
+			i++;
+		}
+	}
+	return;
+}
+
+t_nrPolar_paramsPtr nr_polar_params (t_nrPolar_paramsPtr polarParams,
+									 int8_t messageType,
+									 uint16_t messageLength,
+									 uint8_t aggregation_level)
+{
+	t_nrPolar_paramsPtr currentPtr = NULL;
+
+	while (polarParams != NULL) {
+		if (polarParams->idx ==
+				(messageType * messageLength * (nr_polar_aggregation_prime(aggregation_level)) )) {
+			currentPtr = polarParams;
+			break;
+		} else {
+			polarParams = polarParams->nextPtr;
+		}
+	}
+	return currentPtr;
+}
+
+uint16_t nr_polar_aggregation_prime (uint8_t aggregation_level)
+{
+	if (aggregation_level == 0) return 0;
+	else if (aggregation_level == 1) return NR_POLAR_AGGREGATION_LEVEL_1_PRIME;
+	else if (aggregation_level == 2) return NR_POLAR_AGGREGATION_LEVEL_2_PRIME;
+	else if (aggregation_level == 4) return NR_POLAR_AGGREGATION_LEVEL_4_PRIME;
+	else if (aggregation_level == 8) return NR_POLAR_AGGREGATION_LEVEL_8_PRIME;
+	else return NR_POLAR_AGGREGATION_LEVEL_16_PRIME; //aggregation_level == 16
+}

openair1/PHY/CODING/nr_segmentation.c

@@ -24,8 +24,8 @@
    author: Hongzhi WANG (TCL)
    date: 12.09.2017
 */
-#include "PHY/defs.h"
-#include "SCHED/extern.h"
+#include "PHY/defs_nr_UE.h"
+//#include "SCHED/extern.h"
 
 //#define DEBUG_SEGMENTATION
 

openair1/PHY/INIT/nr_init.c

@@ -20,8 +20,8 @@
  */
 
 #include "PHY/defs_gNB.h"
-#include "SCHED/sched_eNB.h"
 #include "PHY/phy_extern.h"
+#include "PHY/NR_REFSIG/nr_refsig.h"
 #include "PHY/INIT/phy_init.h"
 #include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h"
 #include "RadioResourceConfigCommonSIB.h"
@@ -32,7 +32,7 @@
 #include "assertions.h"
 #include <math.h>
 
-#include "PHY/NR_REFSIG/defs.h" 
+#include "PHY/NR_REFSIG/nr_refsig.h" 
 #include "PHY/LTE_REFSIG/lte_refsig.h"
 #include "SCHED_NR/fapi_nr_l1.h"
 
@@ -118,7 +118,25 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB,
   // PBCH DMRS gold sequences generation
   nr_init_pbch_dmrs(gNB);
   // Polar encoder init for PBCH
-  nr_polar_init(&fp->pbch_polar_params, 1);
+  nr_polar_init(&gNB->nrPolar_params,
+        NR_POLAR_PBCH_MESSAGE_TYPE,
+				NR_POLAR_PBCH_PAYLOAD_BITS,
+				NR_POLAR_PBCH_AGGREGATION_LEVEL);
+
+  //PDCCH DMRS init
+  gNB->nr_gold_pdcch_dmrs = (uint32_t ***)malloc16(fp->slots_per_frame*sizeof(uint32_t**));
+  uint32_t ***pdcch_dmrs             = gNB->nr_gold_pdcch_dmrs;
+  AssertFatal(pdcch_dmrs!=NULL, "NR init: pdcch_dmrs malloc failed\n");
+  for (int slot=0; slot<fp->slots_per_frame; slot++) {
+    pdcch_dmrs[slot] = (uint32_t **)malloc16(fp->symbols_per_slot*sizeof(uint32_t*));
+    AssertFatal(pdcch_dmrs[slot]!=NULL, "NR init: pdcch_dmrs for slot %d - malloc failed\n", slot);
+    for (int symb=0; symb<fp->symbols_per_slot; symb++){
+      pdcch_dmrs[slot][symb] = (uint32_t *)malloc16(NR_MAX_PDCCH_DMRS_INIT_LENGTH_DWORD*sizeof(uint32_t));
+      AssertFatal(pdcch_dmrs[slot][symb]!=NULL, "NR init: pdcch_dmrs for slot %d symbol %d - malloc failed\n", slot, symb);
+    }
+  }
+
+  nr_init_pdcch_dmrs(gNB, cfg->sch_config.physical_cell_id.value);
 
 /*
   lte_gold(fp,gNB->lte_gold_table,fp->Nid_cell);
@@ -276,6 +294,7 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
   LTE_eNB_PUSCH** const pusch_vars   = gNB->pusch_vars;
   LTE_eNB_SRS* const srs_vars        = gNB->srs_vars;
   LTE_eNB_PRACH* const prach_vars    = &gNB->prach_vars;
+  uint32_t ***pdcch_dmrs             = gNB->nr_gold_pdcch_dmrs;
 
   int i, UE_id;
 
@@ -288,6 +307,9 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
   free_and_zero(common_vars->txdataF);
   free_and_zero(common_vars->rxdataF);
 
+  // PDCCH DMRS sequences
+  free_and_zero(pdcch_dmrs);
+
   // Channel estimates for SRS
   for (UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++) {
     for (i=0; i<64; i++) {

openair1/PHY/INIT/nr_init_ue.c

@@ -34,6 +34,9 @@
 #include "PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h"
 #include "PHY/LTE_REFSIG/lte_refsig.h"
 #include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h"
+#include "PHY/INIT/phy_init.h"
+#include "PHY/NR_REFSIG/pss_nr.h"
+#include "openair1/PHY/NR_REFSIG/ul_ref_seq_nr.h"
 
 //uint8_t dmrs1_tab_ue[8] = {0,2,3,4,6,8,9,10};
 
@@ -324,6 +327,7 @@ void phy_config_sib13_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,int mbsfn_Area_
   }
 }
 
+
 void phy_config_meas_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index,uint8_t n_adj_cells,unsigned int *adj_cell_id)
 {
 
@@ -341,6 +345,7 @@ void phy_config_meas_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index,uint8_t n
   memcpy((void*)phy_meas->adj_cell_id,(void *)adj_cell_id,n_adj_cells*sizeof(unsigned int));
 
 }
+*/
 
 #if defined(Rel10) || defined(Rel14)
 void phy_config_dedicated_scell_ue(uint8_t Mod_id,
@@ -352,17 +357,17 @@ void phy_config_dedicated_scell_ue(uint8_t Mod_id,
 }
 #endif
 
-
 void phy_config_harq_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,
                         uint16_t max_harq_tx )
 {
 
-  PHY_VARS_UE *phy_vars_ue = PHY_vars_UE_g[Mod_id][CC_id];
+  PHY_VARS_NR_UE *phy_vars_ue = PHY_vars_UE_g[Mod_id][CC_id];
   phy_vars_ue->ulsch[eNB_id]->Mlimit = max_harq_tx;
 }
 
 extern uint16_t beta_cqi[16];
 
+/*
 void phy_config_dedicated_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,
                              struct PhysicalConfigDedicated *physicalConfigDedicated )
 {
@@ -658,8 +663,8 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
   printf("Initializing UE vars (abstraction %"PRIu8") for eNB TXant %"PRIu8", UE RXant %"PRIu8"\n",abstraction_flag,fp->nb_antennas_tx,fp->nb_antennas_rx);
   //LOG_D(PHY,"[MSC_NEW][FRAME 00000][PHY_UE][MOD %02u][]\n", ue->Mod_id+NB_eNB_INST);
   
-  //phy_init_nr_top(&ue->frame_parms);
-  //nr_init_frame_parms_ue(&ue->frame_parms);
+  nr_init_frame_parms_ue(&ue->frame_parms);
+  phy_init_nr_top(ue);
 
   // many memory allocation sizes are hard coded
   AssertFatal( fp->nb_antennas_rx <= 2, "hard coded allocation for ue_common_vars->dl_ch_estimates[eNB_id]" );
@@ -905,8 +910,9 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue,
   return 0;
 
 }
+
 /*
-void nr_lte_ue_transport(PHY_VARS_UE *ue,int abstraction_flag) {
+void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag) {
 
   int i,j,k;
 
@@ -927,14 +933,17 @@ void nr_lte_ue_transport(PHY_VARS_UE *ue,int abstraction_flag) {
     ue->transmission_mode[i] = ue->frame_parms.nb_antenna_ports_eNB==1 ? 1 : 2;
   }
 
-  ue->frame_parms.pucch_config_common.deltaPUCCH_Shift = 1;
+  //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);
 
 }*/
 
-void phy_init_nr_top(NR_DL_FRAME_PARMS *frame_parms)
+void phy_init_nr_top(PHY_VARS_NR_UE *ue)
 {
+	NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
+	NR_UE_DLSCH_t *dlsch0 = ue->dlsch[0][0][0];
+	dlsch0 =(NR_UE_DLSCH_t *)malloc16(sizeof(NR_UE_DLSCH_t));
 
   crcTableInit();
 
@@ -960,7 +969,12 @@ void phy_init_nr_top(NR_DL_FRAME_PARMS *frame_parms)
   generate_ul_reference_signal_sequences(SHRT_MAX);
 
   // Polar encoder init for PBCH
-  nr_polar_init(&frame_parms->pbch_polar_params, 1);
+  //nr_polar_init(&frame_parms->pbch_polar_params, 1);
+  /*t_nrPolar_paramsPtr nrPolar_params = NULL, currentPtr = NULL;
+  nr_polar_init(&ue->nrPolar_params,
+    		  	  	NR_POLAR_PBCH_MESSAGE_TYPE,
+					NR_POLAR_PBCH_PAYLOAD_BITS,
+					NR_POLAR_PBCH_AGGREGATION_LEVEL);*/
 
   //lte_sync_time_init(frame_parms);
 

openair1/PHY/INIT/nr_parms.c

@@ -40,7 +40,7 @@ int nr_init_frame_parms(nfapi_nr_config_request_t* config,
   LOG_I(PHY,"Initializing frame parms for mu %d, N_RB %d, Ncp %d\n",mu, N_RB, Ncp);
 #endif
 
-  if (Ncp == EXTENDED)
+  if (Ncp == NFAPI_CP_EXTENDED)
     AssertFatal(mu == NR_MU_2,"Invalid cyclic prefix %d for numerology index %d\n", Ncp, mu);
 
   switch(mu) {
@@ -139,7 +139,7 @@ int nr_init_frame_parms(nfapi_nr_config_request_t* config,
     AssertFatal(1==0,"Invalid numerology index %d", mu);
   }
 
-
+  frame_parms->slots_per_frame = 10* frame_parms->slots_per_subframe;
   frame_parms->symbols_per_slot = ((Ncp == NORMAL)? 14 : 12); // to redefine for different slot formats
   frame_parms->samples_per_subframe_wCP = frame_parms->ofdm_symbol_size * frame_parms->symbols_per_slot * frame_parms->slots_per_subframe;
   frame_parms->samples_per_frame_wCP = 10 * frame_parms->samples_per_subframe_wCP;
@@ -148,6 +148,14 @@ int nr_init_frame_parms(nfapi_nr_config_request_t* config,
   frame_parms->samples_per_frame = 10 * frame_parms->samples_per_subframe;
   frame_parms->freq_range = (frame_parms->dl_CarrierFreq < 6e9)? nr_FR1 : nr_FR2;
 
+  // Initial bandwidth part configuration -- full carrier bandwidth
+  frame_parms->initial_bwp_dl.bwp_id = 0;
+  frame_parms->initial_bwp_dl.scs = frame_parms->subcarrier_spacing;
+  frame_parms->initial_bwp_dl.location = 0;
+  frame_parms->initial_bwp_dl.N_RB = N_RB;
+  frame_parms->initial_bwp_dl.cyclic_prefix = Ncp;
+  frame_parms->initial_bwp_dl.ofdm_symbol_size = frame_parms->ofdm_symbol_size;
+
   return 0;
 }
 
@@ -276,6 +284,7 @@ int nr_init_frame_parms_ue(NR_DL_FRAME_PARMS *frame_parms)
     frame_parms->samples_per_subframe = 30720 * frame_parms->ttis_per_subframe;
     //frame_parms->first_carrier_offset = 2048-600;
 
+  frame_parms->slots_per_frame = 10* frame_parms->slots_per_subframe;
   frame_parms->symbols_per_slot = ((Ncp == NORMAL)? 14 : 12); // to redefine for different slot formats
   frame_parms->samples_per_subframe_wCP = frame_parms->ofdm_symbol_size * frame_parms->symbols_per_slot * frame_parms->slots_per_subframe;
   frame_parms->samples_per_frame_wCP = 10 * frame_parms->samples_per_subframe_wCP;
@@ -298,4 +307,10 @@ void nr_dump_frame_parms(NR_DL_FRAME_PARMS *frame_parms)
   LOG_I(PHY,"frame_parms->samples_per_frame_wCP=%d\n",frame_parms->samples_per_frame_wCP);
   LOG_I(PHY,"frame_parms->samples_per_subframe=%d\n",frame_parms->samples_per_subframe);
   LOG_I(PHY,"frame_parms->samples_per_frame=%d\n",frame_parms->samples_per_frame);
+  LOG_I(PHY,"frame_parms->initial_bwp_dl.bwp_id=%d\n",frame_parms->initial_bwp_dl.bwp_id);
+  LOG_I(PHY,"frame_parms->initial_bwp_dl.scs=%d\n",frame_parms->initial_bwp_dl.scs);
+  LOG_I(PHY,"frame_parms->initial_bwp_dl.N_RB=%d\n",frame_parms->initial_bwp_dl.N_RB);
+  LOG_I(PHY,"frame_parms->initial_bwp_dl.cyclic_prefix=%d\n",frame_parms->initial_bwp_dl.cyclic_prefix);
+  LOG_I(PHY,"frame_parms->initial_bwp_dl.location=%d\n",frame_parms->initial_bwp_dl.location);
+  LOG_I(PHY,"frame_parms->initial_bwp_dl.ofdm_symbol_size=%d\n",frame_parms->initial_bwp_dl.ofdm_symbol_size);
 }

openair1/PHY/INIT/phy_init.h

@@ -56,6 +56,8 @@ int l1_north_init_eNB(void);
  */
 int phy_init_top(LTE_DL_FRAME_PARMS *frame_parms);
 
+void phy_init_nr_top(PHY_VARS_NR_UE *ue);
+
 
 /*!
 \brief Allocate and Initialize the PHY variables relevant to the LTE ue signal buffers.

openair1/PHY/LTE_TRANSPORT/dci_tools.c

@@ -224,7 +224,12 @@ void fill_pdcch_order(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,DCI_ALLOC_t *dci_a
         proc->frame_tx, proc->subframe_tx, rel8->rnti);
 }
 
-void fill_dci_and_dlsch(PHY_VARS_eNB *eNB,int frame,int subframe,eNB_rxtx_proc_t *proc,DCI_ALLOC_t *dci_alloc,nfapi_dl_config_dci_dl_pdu *pdu)
+void fill_dci_and_dlsch(PHY_VARS_eNB *eNB,
+						int frame,
+						int subframe,
+						eNB_rxtx_proc_t *proc,
+						DCI_ALLOC_t *dci_alloc,
+						nfapi_dl_config_dci_dl_pdu *pdu)
 {
   LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
   uint8_t *dci_pdu = &dci_alloc->dci_pdu[0];

openair1/PHY/NR_REFSIG/nr_dmrs_rx.c

@@ -115,7 +115,8 @@ int nr_pdsch_dmrs_rx(PHY_VARS_NR_UE *ue,
 						unsigned short nb_rb_pdsch)
 {
   int32_t qpsk[4],nqpsk[4],*qpsk_p, n;
-  int w,mprime,ind,l,ind_dword,ind_qpsk_symb,kp,lp, config_type, k;
+  //int w,mprime,ind,l,ind_dword,ind_qpsk_symb,kp,lp, config_type, k;
+  int w,ind,ind_dword,ind_qpsk_symb,kp,lp, config_type, k=0;
   short pamp;
 
   typedef int array_of_w[2];
@@ -196,7 +197,7 @@ int nr_pdcch_dmrs_rx(PHY_VARS_NR_UE *ue,
 {
 
 	uint8_t idx=0;
-	uint8_t pdcch_rb_offset =0;
+	//uint8_t pdcch_rb_offset =0;
 	//nr_gold_pdcch += ((int)floor(ue->frame_parms.ssb_start_subcarrier/12)+pdcch_rb_offset)*3/32;
 
 	if (p==2000) {

openair1/PHY/NR_REFSIG/nr_gold.c

@@ -19,16 +19,16 @@
  *      contact@openairinterface.org
  */
 
-#include "defs.h"
+#include "nr_refsig.h"
 
 void nr_init_pbch_dmrs(PHY_VARS_gNB* gNB)
 {
-
-  unsigned int n, x1, x2;
+  unsigned int x1, x2;
   unsigned char Nid, i_ssb, i_ssb2;
   unsigned char Lmax, l, n_hf, N_hf;
   nfapi_nr_config_request_t *cfg = &gNB->gNB_config;
   NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+  uint8_t reset;
 
   Nid = cfg->sch_config.physical_cell_id.value;
 
@@ -36,32 +36,42 @@ void nr_init_pbch_dmrs(PHY_VARS_gNB* gNB)
   N_hf = (Lmax == 4)? 2:1;
 
   for (n_hf = 0; n_hf < N_hf; n_hf++) {
-
     for (l = 0; l < Lmax ; l++) {
       i_ssb = l & (Lmax-1);
       i_ssb2 = (i_ssb<<2) + n_hf;
 
-      x1 = 1 + (1<<31);
+      reset = 1;
       x2 = (1<<11) * (i_ssb2 + 1) * ((Nid>>2) + 1) + (1<<6) * (i_ssb2 + 1) + (Nid&3);
-      x2 = x2 ^ ((x2 ^ (x2>>1) ^ (x2>>2) ^ (x2>>3))<<31);
-
-      // skip first 50 double words (1600 bits)
-      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<NR_PBCH_DMRS_LENGTH_DWORD; 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);
-        gNB->nr_gold_pbch_dmrs[n_hf][l][n] = x1 ^ x2;
+      for (uint8_t n=0; n<NR_PBCH_DMRS_LENGTH_DWORD; n++) {
+        gNB->nr_gold_pbch_dmrs[n_hf][l][n] = lte_gold_generic(&x1, &x2, reset);
+        reset = 0;
       }
 
     }
   }
 
 }
+
+void nr_init_pdcch_dmrs(PHY_VARS_gNB* gNB, uint32_t Nid)
+{
+
+  uint32_t x1, x2;
+  uint8_t reset;
+  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+  uint32_t ***pdcch_dmrs = gNB->nr_gold_pdcch_dmrs;
+
+  for (uint8_t slot=0; slot<fp->slots_per_frame; slot++) {
+    for (uint8_t symb=0; symb<fp->symbols_per_slot; symb++) {
+
+      reset = 1;
+      x2 = ((1<<17) * (14*slot+symb+1) * ((Nid<<1)+1) + (Nid<<1))&(((uint32_t)1<<31)-1);
+
+      for (uint32_t n=0; n<NR_MAX_PDCCH_DMRS_INIT_LENGTH_DWORD; n++) {
+        pdcch_dmrs[slot][symb][n] = lte_gold_generic(&x1, &x2, reset);
+        reset = 0;
+      }
+    }  
+  }
+
+}

openair1/PHY/NR_REFSIG/defs.h → openair1/PHY/NR_REFSIG/nr_refsig.h

@@ -21,15 +21,22 @@
 
 /* Definitions for LTE Reference signals */
 /* Author R. Knopp / EURECOM / OpenAirInterface.org */
-#ifndef __NR_REFSIG_DEFS__H__
-#define __NR_REFSIG_DEFS__H__
+#ifndef __NR_REFSIG__H__
+#define __NR_REFSIG__H__
+
 #include "PHY/defs_gNB.h"
+#include "PHY/LTE_REFSIG/lte_refsig.h"
 
 
 /*!\brief This function generates the NR Gold sequence (38-211, Sec 5.2.1) for the PBCH DMRS.
 @param PHY_VARS_gNB* gNB structure provides configuration, frame parameters and the pointers to the 32 bits sequence storage tables
  */
 void nr_init_pbch_dmrs(PHY_VARS_gNB* gNB);
+/*!\brief This function generates the NR Gold sequence (38-211, Sec 5.2.1) for the PDCCH DMRS.
+@param PHY_VARS_gNB* gNB structure provides configuration, frame parameters and the pointers to the 32 bits sequence storage tables
+@param Nid is used for the initialization of x2, Physical cell Id by default or upper layer configured pdcch_scrambling_ID
+ */
+void nr_init_pdcch_dmrs(PHY_VARS_gNB* gNB, uint32_t Nid);
 
 
 #endif

openair1/PHY/NR_TRANSPORT/nr_dci.h

@@ -22,19 +22,38 @@
 #ifndef __PHY_NR_TRANSPORT_DCI__H
 #define __PHY_NR_TRANSPORT_DCI__H
 
-#include "defs_gNB.h"
+#include "PHY/defs_gNB.h"
+#include "PHY/NR_REFSIG/nr_refsig.h"
 
 typedef unsigned __int128 uint128_t;
 
-uint8_t nr_get_dci_size(nr_dci_format_e format,
-                        nr_rnti_type_e rnti,
-                        NR_BWP_PARMS bwp,
+uint16_t nr_get_dci_size(nfapi_nr_dci_format_e format,
+                        nfapi_nr_rnti_type_e rnti_type,
+                        NR_BWP_PARMS* bwp,
                         nfapi_nr_config_request_t* config);
 
-uint8_t nr_generate_dci_top(NR_DCI_ALLOC_t dci_alloc,
+uint8_t nr_generate_dci_top(NR_gNB_PDCCH pdcch_vars,
+                            t_nrPolar_paramsPtr *nrPolar_params,
+                            uint32_t **gold_pdcch_dmrs,
                             int32_t** txdataF,
                             int16_t amp,
-                            NR_DL_FRAME_PARMS* frame_parms,
-                            nfapi_nr_config_request_t* config)
+                            NR_DL_FRAME_PARMS frame_parms,
+                            nfapi_nr_config_request_t config);
+
+void nr_pdcch_scrambling(uint32_t *in,
+                         uint8_t size,
+                         uint32_t Nid,
+                         uint32_t n_RNTI,
+                         uint32_t* out);
+
+void nr_fill_dci_and_dlsch(PHY_VARS_gNB *gNB,
+                           int frame,
+                           int subframe,
+                           gNB_rxtx_proc_t *proc,
+                           NR_gNB_DCI_ALLOC_t *dci_alloc,
+                           nfapi_nr_dl_config_request_pdu_t *pdu);
+
+void nr_fill_cce_list(NR_gNB_DCI_ALLOC_t* dci_alloc, uint16_t n_shift, uint8_t m);
+
 
 #endif //__PHY_NR_TRANSPORT_DCI__H

openair1/PHY/NR_TRANSPORT/nr_dci_tools.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.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file PHY/NR_TRANSPORT/nr_dci_tools.c
+ * \brief
+ * \author
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email:
+ * \note
+ * \warning
+ */
+
+#include "nr_dci.h"
+
+
+void nr_fill_cce_list(NR_gNB_DCI_ALLOC_t* dci_alloc, uint16_t n_shift, uint8_t m) {
+
+  nr_cce_t* cce;
+  nr_reg_t* reg;
+  nfapi_nr_dl_config_pdcch_parameters_rel15_t* pdcch_params = &dci_alloc->pdcch_params;
+
+  uint8_t L = dci_alloc->L;
+  uint8_t bsize = pdcch_params->reg_bundle_size;
+  uint8_t R = pdcch_params->interleaver_size;
+  uint16_t N_reg = pdcch_params->n_rb * pdcch_params->n_symb;
+  uint16_t Y, N_cce, M_s_max, n_CI=0, tmp, C;
+
+  if (pdcch_params->config_type == NFAPI_NR_CSET_CONFIG_MIB_SIB1)
+    AssertFatal(L>=4, "Invalid aggregation level for SIB1 configured PDCCH %d\n", L);
+
+  N_cce = N_reg / NR_NB_REG_PER_CCE;
+  /*Max number of candidates per aggregation level -- SIB1 configured search space only*/
+  M_s_max = (L==4)?4:(L==8)?2:1;
+
+  if (pdcch_params->search_space_type == NFAPI_NR_SEARCH_SPACE_TYPE_COMMON)
+    Y = 0;
+  else { //NFAPI_NR_SEARCH_SPACE_TYPE_UE_SPECIFIC
+  }
+
+  uint8_t cond = N_reg%(bsize*R);
+  AssertFatal(cond==0, "CCE to REG interleaving: Invalid configuration leading to non integer C\n");
+  C = N_reg/(bsize*R);
+
+  tmp = L * (( Y + (uint16_t)(floor((m*N_cce)/(L*M_s_max))) + n_CI ) % ((uint16_t)floor(N_cce/L)));
+
+  LOG_I(PHY, "CCE list generation for candidate %d: bundle size %d ilv size %d tmp %d\n", m, bsize, R, tmp);
+  for (uint8_t cce_idx=0; cce_idx<L; cce_idx++) {
+    cce = &dci_alloc->cce_list[cce_idx];
+    cce->cce_idx = tmp + cce_idx;
+    LOG_D(PHY, "cce_idx %d\n", cce->cce_idx);
+
+    if (pdcch_params->cr_mapping_type == NFAPI_NR_CCE_REG_MAPPING_INTERLEAVED) {
+      LOG_D(PHY, "Interleaved CCE to REG mapping\n");
+      uint8_t j = cce->cce_idx, j_prime;
+      uint8_t r,c,idx;
+
+      for (uint8_t bundle_idx=0; bundle_idx<NR_NB_REG_PER_CCE/bsize; bundle_idx++) {
+        j_prime = 6*j/bsize + bundle_idx;
+        r = j_prime%R;
+        c = (j_prime-r)/R;
+        idx = (r*C + c + n_shift)%(N_reg/bsize);
+        LOG_D(PHY, "bundle idx = %d \n j = %d \t j_prime = %d \t r = %d \t c = %d\n", idx, j , j_prime, r, c);
+
+        for (uint8_t reg_idx=0; reg_idx<bsize; reg_idx++) {
+          reg = &cce->reg_list[reg_idx];
+          reg->reg_idx = bsize*idx + reg_idx;
+          reg->start_sc_idx = (reg->reg_idx/pdcch_params->n_symb) * NR_NB_SC_PER_RB;
+          reg->symb_idx = reg->reg_idx % pdcch_params->n_symb;
+          LOG_D(PHY, "reg %d symbol %d start subcarrier %d\n", reg->reg_idx, reg->symb_idx, reg->start_sc_idx);
+        }
+      }
+    }
+    else { // NFAPI_NR_CCE_REG_MAPPING_NON_INTERLEAVED
+      LOG_D(PHY, "Non interleaved CCE to REG mapping\n");
+      for (uint8_t reg_idx=0; reg_idx<NR_NB_REG_PER_CCE; reg_idx++) {
+        reg = &cce->reg_list[reg_idx];
+        reg->reg_idx = cce->cce_idx*NR_NB_REG_PER_CCE + reg_idx;
+        reg->start_sc_idx = (reg->reg_idx/pdcch_params->n_symb) * NR_NB_SC_PER_RB;
+        reg->symb_idx = reg->reg_idx % pdcch_params->n_symb;
+        LOG_D(PHY, "reg %d symbol %d start subcarrier %d\n", reg->reg_idx, reg->symb_idx, reg->start_sc_idx);
+      }
+
+    }
+
+  }
+}
+
+void nr_fill_dci_and_dlsch(PHY_VARS_gNB *gNB,
+                           int frame,
+                           int subframe,
+                           gNB_rxtx_proc_t *proc,
+                           NR_gNB_DCI_ALLOC_t *dci_alloc,
+                           nfapi_nr_dl_config_request_pdu_t *pdu)
+{
+	NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+  uint8_t n_shift;
+	uint32_t *dci_pdu = dci_alloc->dci_pdu;
+  memset((void*)dci_pdu,0,4*sizeof(uint32_t));
+	nfapi_nr_dl_config_dci_dl_pdu_rel15_t *pdu_rel15 = &pdu->dci_dl_pdu.dci_dl_pdu_rel15;
+  nfapi_nr_dl_config_pdcch_parameters_rel15_t *params_rel15 = &pdu->dci_dl_pdu.pdcch_params_rel15;
+	nfapi_nr_config_request_t *cfg = &gNB->gNB_config;
+
+  uint16_t N_RB = fp->initial_bwp_dl.N_RB;
+  uint8_t fsize=0, pos=0, cand_idx=0;
+
+  /// Payload generation
+  switch(params_rel15->dci_format) {
+
+    case NFAPI_NR_DL_DCI_FORMAT_1_0:
+      switch(params_rel15->rnti_type) {
+        case NFAPI_NR_RNTI_RA:
+        	// Freq domain assignment
+        	fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
+        	for (int i=0; i<fsize; i++)
+        		*dci_pdu |= ((pdu_rel15->frequency_domain_assignment>>(fsize-i-1))&1)<<pos++;
+        	// Time domain assignment
+        	for (int i=0; i<4; i++)
+        		*dci_pdu |= ((pdu_rel15->time_domain_assignment>>(3-i))&1)<<pos++;
+        	// VRB to PRB mapping
+        	*dci_pdu |= (pdu_rel15->vrb_to_prb_mapping&1)<<pos++;
+        	// MCS
+        	for (int i=0; i<5; i++)
+        		*dci_pdu |= ((pdu_rel15->mcs>>(4-i))&1)<<pos++;
+        	// TB scaling
+        	for (int i=0; i<2; i++)
+        		*dci_pdu |= ((pdu_rel15->tb_scaling>>(1-i))&1)<<pos++;
+        	break;
+      }
+      break;
+
+    case NFAPI_NR_UL_DCI_FORMAT_0_0:
+      break;
+  }
+
+  LOG_I(PHY, "DCI PDU: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
+              dci_pdu[0], dci_pdu[1], dci_pdu[2], dci_pdu[3]);
+
+  /// rest of DCI alloc
+  dci_alloc->L = 8;
+  memcpy((void*)&dci_alloc->pdcch_params, (void*)params_rel15, sizeof(nfapi_nr_dl_config_pdcch_parameters_rel15_t));
+  dci_alloc->size = nr_get_dci_size(dci_alloc->pdcch_params.dci_format,
+                        dci_alloc->pdcch_params.rnti_type,
+                        &fp->initial_bwp_dl,
+                        cfg);
+  n_shift = (dci_alloc->pdcch_params.config_type == NFAPI_NR_CSET_CONFIG_MIB_SIB1)?
+                      cfg->sch_config.physical_cell_id.value : dci_alloc->pdcch_params.shift_index;
+  nr_fill_cce_list(dci_alloc, n_shift, cand_idx);
+  LOG_I(PHY, "DCI type %d payload (size %d) generated on candidate %d\n", dci_alloc->pdcch_params.dci_format, dci_alloc->size, cand_idx);
+
+}

openair1/PHY/NR_TRANSPORT/nr_pbch.c

@@ -136,28 +136,24 @@ void nr_pbch_scrambling(NR_gNB_PBCH *pbch,
                         uint8_t nushift,
                         uint16_t M,
                         uint16_t length,
-                        uint8_t bitwise)
+                        uint8_t encoded)
 {
   uint8_t reset, offset;
   uint32_t x1, x2, s=0;
-  uint8_t *pbch_e = pbch->pbch_e;
-  uint32_t *pbch_a_prime = (uint32_t*)pbch->pbch_a_prime;
-  uint32_t *pbch_a_interleaved = (uint32_t*)pbch->pbch_a_interleaved;
+  uint32_t *pbch_e = pbch->pbch_e;
   uint32_t unscrambling_mask = 0x100006D;
-
   reset = 1;
   // x1 is set in lte_gold_generic
   x2 = Nid;
-
   // The Gold sequence is shifted by nushift* M, so we skip (nushift*M /32) double words
-  for (int i=0; i<(uint16_t)ceil((nushift*M)/32); i++) {
-    s = lte_gold_generic(&x1, &x2, reset);
+  for (int i=0; i<(uint16_t)ceil(((float)nushift*M)/32); i++) {
+s = lte_gold_generic(&x1, &x2, reset);
     reset = 0;
   }
   // Scrambling is now done with offset (nushift*M)%32
   offset = (nushift*M)&0x1f;
 #ifdef DEBUG_PBCH_ENCODING
-  printf("Scrambling params: nushift %d M %d length %d bitwise %d offset %d\n", nushift, M, length, bitwise, offset);
+  printf("Scrambling params: nushift %d M %d length %d encoded %d offset %d\n", nushift, M, length, encoded, offset);
 #endif
 
   for (int i=0; i<length; i++) {
@@ -168,12 +164,11 @@ void nr_pbch_scrambling(NR_gNB_PBCH *pbch,
 #ifdef DEBUG_PBCH_ENCODING
   printf("s: %04x\t", s);
 #endif
-    if (bitwise) {
-      (*pbch_a_prime) ^= ((unscrambling_mask>>i)&1)? (((*pbch_a_interleaved)>>i)&1)<<i : ((((*pbch_a_interleaved)>>i)&1) ^ ((s>>((i+offset)&0x1f))&1))<<i;      
-    }
+    if (!encoded)
+      pbch->pbch_a_prime ^= ((unscrambling_mask>>i)&1)? ((pbch->pbch_a_interleaved>>i)&1)<<i : (((pbch->pbch_a_interleaved>>i)&1) ^ ((s>>((i+offset)&0x1f))&1))<<i;      
 
     else
-      pbch_e[i] = (pbch_e[i]&1) ^ ((s>>((i+offset)&0x1f))&1);
+      pbch_e[i>>5] ^= (((s>>((i+offset)&0x1f))&1)<<(i&0x1f));
   }
 }
 
@@ -199,6 +194,7 @@ uint8_t nr_pbch_payload_interleaver(uint8_t i) {
 //                                                    29,31,16,23,18,17,8,30,10,6,24,7,0,5,3,2};
 
 int nr_generate_pbch(NR_gNB_PBCH *pbch,
+                     t_nrPolar_paramsPtr polar_params,
                      uint8_t *pbch_pdu,
                      int32_t **txdataF,
                      int16_t amp,
@@ -223,6 +219,7 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
 
   LOG_I(PHY, "PBCH generation started\n");
 
+  memset((void*)pbch, 0, sizeof(NR_gNB_PBCH));
   ///Payload generation
     // Fix byte endian
   if (!(sfn&7))
@@ -257,59 +254,50 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
     in |= (uint32_t)(pbch->pbch_a[i]<<((3-i)<<3));
 
   for (int i=0; i<32; i++) {
-    out |= ((in>>i)&1)<<(nr_pbch_payload_interleaver(i));//nr_pbch_payload_interleaving_pattern[i]
+    pbch->pbch_a_interleaved |= ((in>>i)&1)<<(nr_pbch_payload_interleaver(i));//nr_pbch_payload_interleaving_pattern[i]
 #ifdef DEBUG_PBCH_ENCODING
-  printf("i %d in 0x%08x out 0x%08x ilv %d (in>>i)&1) %d\n", i, in, out, nr_pbch_payload_interleaver(i), (in>>i)&1);
+  printf("i %d in 0x%08x out 0x%08x ilv %d (in>>i)&1) %d\n", i, in, pbch->pbch_a_interleaved, nr_pbch_payload_interleaver(i), (in>>i)&1);
 #endif
   }
 
-  for (int i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS>>3; i++)
-    pbch->pbch_a_interleaved[i] = (uint8_t)((out>>(i<<3))&0xff);
-
 #ifdef DEBUG_PBCH_ENCODING
   printf("Interleaving:\n");
-  for (int i=0; i<4; i++)
-    printf("pbch_a_interleaved[%d]: 0x%02x\n", i, pbch->pbch_a_interleaved[i]);
+  printf("pbch_a_interleaved: 0x%08x\n", pbch->pbch_a_interleaved);
 #endif
 
     // Scrambling
   M = (Lmax == 64)? (NR_POLAR_PBCH_PAYLOAD_BITS - 6) : (NR_POLAR_PBCH_PAYLOAD_BITS - 3);
   nushift = (((sfn>>2)&1)<<1) ^ ((sfn>>1)&1);
-  nr_pbch_scrambling(pbch, (uint32_t)config->sch_config.physical_cell_id.value, nushift, M, NR_POLAR_PBCH_PAYLOAD_BITS, 1);
+  pbch->pbch_a_prime = 0;
+  nr_pbch_scrambling(pbch, (uint32_t)config->sch_config.physical_cell_id.value, nushift, M, NR_POLAR_PBCH_PAYLOAD_BITS, 0);
 #ifdef DEBUG_PBCH_ENCODING
-  printf("Payload scrambling:\n");
-  for (int i=0; i<4; i++)
-    printf("pbch_a_prime[%d]: 0x%02x\n", i, pbch->pbch_a_prime[i]);
+  printf("Payload scrambling: nushift %d M %d sfn3 %d sfn2 %d\n", nushift, M, (sfn>>2)&1, (sfn>>1)&1);
+  printf("pbch_a_prime: 0x%08x\n", pbch->pbch_a_prime);
 #endif
 
-for (int m=0;m<32;m++){
-pbch_a_b[m] = ((pbch->pbch_a_prime[m/8]>>(m&7))&01);
-//printf("pbch_a_b[%d] %d\n", m, pbch_a_b[m] );
-}
-
   /// CRC, coding and rate matching
-  polar_encoder (pbch->pbch_a_prime, pbch->pbch_e, &frame_parms->pbch_polar_params);
+  polar_encoder (&pbch->pbch_a_prime, pbch->pbch_e, polar_params);
 #ifdef DEBUG_PBCH_ENCODING
   printf("Channel coding:\n");
-  for (int i=0; i<NR_POLAR_PBCH_E>>3; i++)
-    printf("pbch_e[%d]: 0x%02x\t", i, pbch->pbch_e[i]);
+  for (int i=0; i<NR_POLAR_PBCH_E_DWORD; i++)
+    printf("pbch_e[%d]: 0x%08x\t", i, pbch->pbch_e[i]);
   printf("\n");
 #endif
 
   /// Scrambling
   M =  NR_POLAR_PBCH_E;
   nushift = (Lmax==4)? ssb_index&3 : ssb_index&7;
-  nr_pbch_scrambling(pbch, (uint32_t)config->sch_config.physical_cell_id.value, nushift, M, NR_POLAR_PBCH_E, 0);
+  nr_pbch_scrambling(pbch, (uint32_t)config->sch_config.physical_cell_id.value, nushift, M, NR_POLAR_PBCH_E, 1);
 #ifdef DEBUG_PBCH_ENCODING
   printf("Scrambling:\n");
-  for (int i=0; i<NR_POLAR_PBCH_E>>3; i++)
-    printf("pbch_e[%d]: 0x%02x\t", i, pbch->pbch_e[i]);
+  for (int i=0; i<NR_POLAR_PBCH_E_DWORD; i++)
+    printf("pbch_e[%d]: 0x%08x\t", i, pbch->pbch_e[i]);
   printf("\n");
 #endif
 
   /// QPSK modulation
   for (int i=0; i<NR_POLAR_PBCH_E>>1; i++){
-    idx = ((pbch->pbch_e[i<<1]&1)<<1) ^ (pbch->pbch_e[(i<<1)+1]&1);
+    idx = (((pbch->pbch_e[(i<<1)>>5]>>((i<<1)&0x1f))&1)<<1) ^ ((pbch->pbch_e[((i<<1)+1)>>5]>>(((i<<1)+1)&0x1f))&1);
     mod_pbch_e[i<<1] = nr_mod_table[(NR_MOD_TABLE_QPSK_OFFSET + idx)<<1];
     mod_pbch_e[(i<<1)+1] = nr_mod_table[((NR_MOD_TABLE_QPSK_OFFSET + idx)<<1)+1];
 

openair1/PHY/NR_TRANSPORT/nr_pdcch.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.1  (the "License"); you may not use this file
- * except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.openairinterface.org/?page_id=698
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *-------------------------------------------------------------------------------
- * For more information about the OpenAirInterface (OAI) Software Alliance:
- *      contact@openairinterface.org
- */
-
-/*! \file PHY/NR_TRANSPORT/nr_pdcch.c
-* \brief Implements PDCCH physical channel TX/RX procedures (38.211). Current NR compliance V15.1 2018-06.
-* \author Guy De Souza
-* \date 2018
-* \version 0.1
-* \company Eurecom
-* \email: desouza@eurecom.fr
-* \note
-* \warning
-*/
-
-#include "nr_dci.h"
-
-

openair1/PHY/NR_TRANSPORT/nr_transport.h

@@ -75,7 +75,7 @@ void nr_pbch_scrambling(NR_gNB_PBCH *pbch,
                         uint8_t nushift,
                         uint16_t M,
                         uint16_t length,
-                        uint8_t bitwise);
+                        uint8_t encoded);
 
 /*!
 \fn int nr_generate_pbch
@@ -84,6 +84,7 @@ void nr_pbch_scrambling(NR_gNB_PBCH *pbch,
 @returns 0 on success
  */
 int nr_generate_pbch(NR_gNB_PBCH *pbch,
+                     t_nrPolar_paramsPtr polar_params,
                      uint8_t *pbch_pdu,
                      int32_t **txdataF,
                      int16_t amp,

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -326,10 +326,17 @@ int nr_pdcch_channel_estimation(PHY_VARS_NR_UE *ue,
                                          ch,
                                          dl_ch,
                                          16);
+                                         
+#ifdef DEBUG_CH       
+      for (int m =0; m<12; m++)
+      printf("data :  dl_ch -> (%d,%d)\n",dl_ch[0+2*m],dl_ch[1+2*m]);
+#endif      
       pil+=2;
       rxF+=8;
       dl_ch+=24;
       k+=12;
+      
+      
 
       for (pilot_cnt=3; pilot_cnt<(3*nb_rb_coreset); pilot_cnt+=3) {
 

openair1/PHY/NR_UE_TRANSPORT/dci_nr.h

@@ -49,8 +49,8 @@ struct NR_DCI_INFO_EXTRACTED {
   uint8_t sul_ind_0_1                     ; // 2  SUL_IND_0_1:
   uint8_t slot_format_ind                 ; // 3  SLOT_FORMAT_IND: size of DCI format 2_0 is configurable by higher layers up to 128 bits, according to Subclause 11.1.1 of [5, TS 38.213]
   uint8_t pre_emption_ind                 ; // 4  PRE_EMPTION_IND: size of DCI format 2_1 is configurable by higher layers up to 126 bits, according to Subclause 11.2 of [5, TS 38.213]. Each pre-emption indication is 14 bits
-  uint8_t tpc_cmd_number                  ; // 5  TPC_CMD_NUMBER: The parameter xxx provided by higher layers determines the index to the TPC command number for an UL of a cell. Each TPC command number is 2 bits
-  uint8_t block_number                    ; // 6  BLOCK_NUMBER: starting position of a block is determined by the parameter startingBitOfFormat2_3
+  uint8_t block_number                    ; // 5  BLOCK_NUMBER: starting position of a block is determined by the parameter startingBitOfFormat2_3
+  uint8_t close_loop_ind                  ; // 6  CLOSE_LOOP_IND:
   uint8_t bandwidth_part_ind              ; // 7  BANDWIDTH_PART_IND:
   uint8_t short_message_ind               ; // 8  SHORT_MESSAGE_IND:
   uint8_t short_messages                  ; // 9  SHORT_MESSAGES:
@@ -93,7 +93,7 @@ struct NR_DCI_INFO_EXTRACTED {
   uint8_t antenna_ports                   ; // 38 ANTENNA_PORTS:
   uint8_t tci                             ; // 39 TCI: 0 bit if higher layer parameter tci-PresentInDCI is not enabled; otherwise 3 bits
   uint8_t srs_request                     ; // 40 SRS_REQUEST:
-  uint8_t tpc_cmd_number_format2_3        ; // 41 TPC_CMD_NUMBER_FORMAT2_3:
+  uint8_t tpc_cmd                         ; // 41 TPC_CMD:
   uint8_t csi_request                     ; // 42 CSI_REQUEST:
   uint8_t cbgti                           ; // 43 CBGTI: 0, 2, 4, 6, or 8 bits determined by higher layer parameter maxCodeBlockGroupsPerTransportBlock for the PDSCH
   uint8_t cbgfi                           ; // 44 CBGFI: 0 or 1 bit determined by higher layer parameter codeBlockGroupFlushIndicator

openair1/SCHED_NR/fapi_nr_l1.h

@@ -38,4 +38,8 @@
 #include "SCHED_NR/sched_nr.h"
 #include "nfapi_nr_interface.h"
 
-void nr_schedule_response(NR_Sched_Rsp_t *Sched_INFO);
+void nr_schedule_response(NR_Sched_Rsp_t *Sched_INFO);
\ No newline at end of file
+void handle_nfapi_nr_dci_dl_pdu(PHY_VARS_gNB *gNB,
+                                int frame, int subframe,
+                                gNB_rxtx_proc_t *proc,
+                                nfapi_nr_dl_config_request_pdu_t *dl_config_pdu);