delete dead files

openair1/PHY/MODULATION/nr_modulation.c

@@ -318,7 +318,7 @@ void nr_layer_mapping(int nbCodes,
   }
 }
 
-void nr_ue_layer_mapping(const c16_t *mod_symbs, const int n_layers, const int n_symbs, c16_t **tx_layers)
+void nr_ue_layer_mapping(const c16_t *mod_symbs, const int n_layers, const int n_symbs, int sz, c16_t tx_layers[][sz])
 {
   for (int i=0; i<n_symbs/n_layers; i++) {
     for (int l=0; l<n_layers; l++) {
@@ -654,7 +654,7 @@ void init_timeshift_rotation(NR_DL_FRAME_PARMS *fp)
   }
 }
 
-c16_t nr_layer_precoder(c16_t **datatx_F_precoding, const char *prec_matrix, uint8_t n_layers, int32_t re_offset)
+c16_t nr_layer_precoder(int sz, c16_t datatx_F_precoding[][sz], const char *prec_matrix, uint8_t n_layers, int32_t re_offset)
 {
   c16_t precodatatx_F = {0};
 

openair1/PHY/MODULATION/nr_modulation.h

@@ -68,7 +68,7 @@ void nr_layer_mapping(int nbCodes,
   @param[in] n_symbs, number of modulated symbols
   @param[out] tx_layers, modulated symbols for each layer
 */
-void nr_ue_layer_mapping(const c16_t *mod_symbs, const int n_layers, const int n_symbs, c16_t **tx_layers);
+void nr_ue_layer_mapping(const c16_t *mod_symbs, const int n_layers, const int n_symbs, int sz, c16_t tx_layers[][sz]);
 /*!
 \brief This function implements the OFDM front end processor on reception (FEP)
 \param frame_parms Pointer to frame parameters
@@ -131,7 +131,7 @@ void apply_nr_rotation_RX(NR_DL_FRAME_PARMS *frame_parms,
   @param[in] prec_matrix, Pointer to precoding matrix
   @param[in] n_layers, number of DLSCH layers
 */
-c16_t nr_layer_precoder(c16_t **datatx_F_precoding, const char *prec_matrix, uint8_t n_layers, int32_t re_offset);
+c16_t nr_layer_precoder(int sz, c16_t datatx_F_precoding[][sz], const char *prec_matrix, uint8_t n_layers, int32_t re_offset);
 
 c16_t nr_layer_precoder_cm(int n_layers,
                            int n_symbols,

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_ue.c

@@ -253,12 +253,11 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
 
   /////////////////////////ULSCH layer mapping/////////////////////////
   ///////////
+  const int sz = available_bits / mod_order;
+  c16_t tx_layers[Nl][sz];
+  memset(tx_layers, 0, sizeof(tx_layers));
 
-  c16_t **tx_layers = (c16_t **)malloc16_clear(Nl * sizeof(c16_t *));
-  for (int nl=0; nl<Nl; nl++)
-    tx_layers[nl] = malloc16_clear(available_bits / mod_order * sizeof(c16_t));
-
-  nr_ue_layer_mapping(d_mod, Nl, available_bits / mod_order, tx_layers);
+  nr_ue_layer_mapping(d_mod, Nl, available_bits / mod_order, sz, tx_layers);
 
   ///////////
   ////////////////////////////////////////////////////////////////////////
@@ -340,10 +339,9 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
   /////////////////////////ULSCH RE mapping/////////////////////////
   ///////////
 
-  int encoded_length = frame_parms->N_RB_UL*14*NR_NB_SC_PER_RB*mod_order*Nl;
-  c16_t **tx_precoding = malloc16_clear(Nl * sizeof(c16_t *));
-  for (int nl=0; nl<Nl; nl++)
-    tx_precoding[nl] = malloc16_clear(encoded_length * sizeof(c16_t));
+  const int encoded_length = frame_parms->N_RB_UL * 14 * NR_NB_SC_PER_RB * mod_order * Nl;
+  c16_t tx_precoding[Nl][encoded_length];
+  memset(tx_precoding, 0, sizeof(tx_precoding));
 
   for (int nl=0; nl < Nl; nl++) {
     uint8_t k_prime = 0;
@@ -428,7 +426,14 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
 
 #ifdef DEBUG_PUSCH_MAPPING
           printf("DMRS: Layer: %d\t, dmrs_idx %d\t l %d \t k %d \t k_prime %d \t n %d \t dmrs: %d %d\n",
-                 nl, dmrs_idx, l, k, k_prime, n, tx_precoding[nl])[sample_offsetF].r,tx_precoding[nl])[sample_offsetF].i);
+                 nl,
+                 dmrs_idx,
+                 l,
+                 k,
+                 k_prime,
+                 n,
+                 tx_precoding[nl][sample_offsetF].r,
+                 tx_precoding[nl][sample_offsetF].i);
 #endif
 
           dmrs_idx++;
@@ -453,8 +458,8 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
                  m,
                  l,
                  k,
-                 ((int16_t *)tx_precoding[nl])[(sample_offsetF) << 1],
-                 ((int16_t *)tx_precoding[nl])[((sample_offsetF) << 1) + 1]);
+                 tx_precoding[nl][sample_offsetF].r,
+                 tx_precoding[nl][sample_offsetF].i);
 #endif
 
           m++;
@@ -543,7 +548,7 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
 
           for (int i = 0; i < NR_NB_SC_PER_RB; i++) {
             int32_t re_offset = l * frame_parms->ofdm_symbol_size + k;
-            txdataF[ap][re_offset] = nr_layer_precoder(tx_precoding, W_prec, pusch_pdu->nrOfLayers, re_offset);
+            txdataF[ap][re_offset] = nr_layer_precoder(encoded_length, tx_precoding, W_prec, pusch_pdu->nrOfLayers, re_offset);
             if (++k >= frame_parms->ofdm_symbol_size) {
               k -= frame_parms->ofdm_symbol_size;
             }
@@ -556,14 +561,6 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
   NR_UL_UE_HARQ_t *harq_process_ulsch = NULL;
   harq_process_ulsch = &UE->ul_harq_processes[harq_pid];
   harq_process_ulsch->status = SCH_IDLE;
-
-  for (int nl = 0; nl < Nl; nl++) {
-    free_and_zero(tx_layers[nl]);
-    free_and_zero(tx_precoding[nl]);
-  }
-  free_and_zero(tx_layers);
-  free_and_zero(tx_precoding);
-
   ///////////
   ////////////////////////////////////////////////////////////////////////
 }

openair1/PHY/NR_UE_TRANSPORT/pbch_nr.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
- */
-
-/**********************************************************************
-*
-* FILENAME    :  pbch_nr.c
-*
-* MODULE      :  broacast channel
-*
-* DESCRIPTION :  generation of pbch
-*                3GPP TS 38.211 7.3.3 Physical broadcast channel
-*
-************************************************************************/
-
-#include <stdio.h>
-#include <assert.h>
-#include <errno.h>
-
-#include "PHY/defs.h"
-
-#define DEFINE_VARIABLES_PBCH_NR_H
-#include "PHY/NR_REFSIG/pbch_nr.h"
-#undef DEFINE_VARIABLES_PBCH_NR_H
-
-/*******************************************************************
-*
-* NAME :         pseudo_random_gold_sequence
-*
-* PARAMETERS :
-*
-* RETURN :       generate pseudo-random sequence which is a length-31 Gold sequence
-*
-* DESCRIPTION :  3GPP TS 38.211 5.2.1 Pseudo-random sequence generation
-*                Sequence generation
-*
-*********************************************************************/
-
-#define NC           (1600)
-#define GOLD_LENGTH  (31)
-
-uint32_t *pseudo_random_gold_sequence(length M_PN, uint32_t cinit)
-{
-  int size = M_PN * sizeof(uint32_t);
-  int size_x = sizeof(int)*M_PN + size;
-  int *x1 = malloc(size_x);
-  int *x2 = malloc(size_x);
-
-  if ((x1 == NULL) || (x2 == NULL)) {
-    msg("Fatal memory allocation problem \n");
-	assert(0);
-  }
-  else {
-    bzero(x1, size_x);
-    bzero(x2, size_x);
-  }
-
-  x1[0] = 1;
-
-  for (n = 0; n < 31; n++) {
-     x2[n] = (cinit >> n) & 0x1;
-  }
-
-  for (int n = 0; n < (NC+M_PN); n++) {
-    x1(n+31) = (x1(n+3) + x1(n))%2;
-    x2(n+31) = (x2(n+3) + x2(n+2) + x2(n+1) + x2(n))%2;
-  }
-
-  int *c = calloc(size);
-  if (c != NULL) {
-    bzero(c, size);
-  }
-  else {
-   msg("Fatal memory allocation problem \n");
-   assert(0);
-  }
-
-  for (int n = 0; n < M_PN; n++) {
-    c(i) = (x1(n+NC) + x2(n+NC))%2;
-  }
-
-  return c;
-}