gNB_scheduler_RA.c 74.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * 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
 */

22 23 24 25 26
/*! \file     gNB_scheduler_RA.c
 * \brief     primitives used for random access
 * \author    Guido Casati
 * \date      2019
 * \email:    guido.casati@iis.fraunhofer.de
27 28 29
 * \version
 */

30
#include "platform_types.h"
31

cig's avatar
cig committed
32
/* MAC */
33 34 35
#include "nr_mac_gNB.h"
#include "NR_MAC_gNB/mac_proto.h"
#include "NR_MAC_COMMON/nr_mac_extern.h"
36

cig's avatar
cig committed
37 38 39
/* Utils */
#include "common/utils/LOG/log.h"
#include "common/utils/LOG/vcd_signal_dumper.h"
cig's avatar
cig committed
40
#include "common/utils/nr/nr_common.h"
41
#include "UTIL/OPT/opt.h"
cig's avatar
cig committed
42
#include "SIMULATION/TOOLS/sim.h" // for taus
43

cig's avatar
cig committed
44
extern RAN_CONTEXT_t RC;
cig's avatar
cig committed
45
extern const uint8_t nr_slots_per_frame[5];
46
extern uint16_t sl_ahead;
47

48
uint8_t DELTA[4]= {2,3,4,6};
49

50 51 52 53 54
#define MAX_NUMBER_OF_SSB 64		
float ssb_per_rach_occasion[8] = {0.125,0.25,0.5,1,2,4,8};

int16_t ssb_index_from_prach(module_id_t module_idP,
                             frame_t frameP,
Florian Kaltenberger's avatar
Florian Kaltenberger committed
55 56 57 58 59 60
			     sub_frame_t slotP,
			     uint16_t preamble_index,
			     uint8_t freq_index,
			     uint8_t symbol) {
  
  gNB_MAC_INST *gNB = RC.nrmac[module_idP];
61
  NR_COMMON_channels_t *cc = &gNB->common_channels[0];
62 63 64 65
  NR_ServingCellConfigCommon_t *scc = cc->ServingCellConfigCommon;
  nfapi_nr_config_request_scf_t *cfg = &RC.nrmac[module_idP]->config[0];

  uint8_t config_index = scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->rach_ConfigGeneric.prach_ConfigurationIndex;
66
  uint8_t fdm = cfg->prach_config.num_prach_fd_occasions.value;
kn.raju's avatar
kn.raju committed
67
  
68
  uint8_t total_RApreambles = MAX_NUM_NR_PRACH_PREAMBLES;
69
  if( scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->totalNumberOfRA_Preambles != NULL)
kn.raju's avatar
kn.raju committed
70 71
    total_RApreambles = *scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->totalNumberOfRA_Preambles;	
  
72
  float  num_ssb_per_RO = ssb_per_rach_occasion[cfg->prach_config.ssb_per_rach.value];	
73
  uint16_t start_symbol_index = 0;
74
  uint8_t mu,N_dur=0,N_t_slot=0,start_symbol = 0, temp_start_symbol = 0, N_RA_slot=0;
kn.raju's avatar
kn.raju committed
75
  uint16_t format,RA_sfn_index = -1;
76
  uint8_t config_period = 1;
kn.raju's avatar
kn.raju committed
77
  uint16_t prach_occasion_id = -1;
78
  uint8_t num_active_ssb = cc->num_active_ssb;
79 80 81 82 83 84 85

  if (scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->msg1_SubcarrierSpacing)
    mu = *scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->msg1_SubcarrierSpacing;
  else
    mu = scc->downlinkConfigCommon->frequencyInfoDL->scs_SpecificCarrierList.list.array[0]->subcarrierSpacing;

  get_nr_prach_info_from_index(config_index,
86 87 88 89 90 91 92 93 94 95 96 97
			       (int)frameP,
			       (int)slotP,
			       scc->downlinkConfigCommon->frequencyInfoDL->absoluteFrequencyPointA,
			       mu,
			       cc->frame_type,
			       &format,
			       &start_symbol,
			       &N_t_slot,
			       &N_dur,
			       &RA_sfn_index,
			       &N_RA_slot,
			       &config_period);
kn.raju's avatar
kn.raju committed
98
  uint8_t index = 0,slot_index = 0;
99
  for (slot_index = 0;slot_index < N_RA_slot; slot_index++) {
100 101 102 103
    if (N_RA_slot <= 1) { //1 PRACH slot in a subframe
       if((mu == 1) || (mu == 3))
         slot_index = 1;  //For scs = 30khz and 120khz
    }
kn.raju's avatar
kn.raju committed
104 105
    for (int i=0; i< N_t_slot; i++) {
      temp_start_symbol = (start_symbol + i * N_dur + 14 * slot_index) % 14;
106 107 108 109 110 111
      if(symbol == temp_start_symbol) {
        start_symbol_index = i;
        break;
      }
    }
  }
kn.raju's avatar
kn.raju committed
112 113 114 115
  if (N_RA_slot <= 1) { //1 PRACH slot in a subframe
    if((mu == 1) || (mu == 3))
      slot_index = 0;  //For scs = 30khz and 120khz
  }
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132

  //  prach_occasion_id = subframe_index * N_t_slot * N_RA_slot * fdm + N_RA_slot_index * N_t_slot * fdm + freq_index + fdm * start_symbol_index; 
  prach_occasion_id = (((frameP % (cc->max_association_period * config_period))/config_period)*cc->total_prach_occasions_per_config_period) +
                      (RA_sfn_index + slot_index) * N_t_slot * fdm + start_symbol_index * fdm + freq_index; 

  //one RO is shared by one or more SSB
  if(num_ssb_per_RO <= 1 )
    index = (int) (prach_occasion_id / (int)(1/num_ssb_per_RO)) % num_active_ssb;
  //one SSB have more than one continuous RO
  else if ( num_ssb_per_RO > 1) {
    index = (prach_occasion_id * (int)num_ssb_per_RO)% num_active_ssb ;
    for(int j = 0;j < num_ssb_per_RO;j++) {
      if(preamble_index <  (((j+1) * total_RApreambles) / num_ssb_per_RO))
        index = index + j;
    }
  }

133
  LOG_D(NR_MAC, "Frame %d, Slot %d: Prach Occasion id = %d ssb per RO = %f number of active SSB %u index = %d fdm %u symbol index %u freq_index %u total_RApreambles %u\n",
134 135
        frameP, slotP, prach_occasion_id, num_ssb_per_RO, num_active_ssb, index, fdm, start_symbol_index, freq_index, total_RApreambles);

136 137
  return index;
}
138 139


140 141 142
//Compute Total active SSBs and RO available
void find_SSB_and_RO_available(module_id_t module_idP) {

143
  gNB_MAC_INST *gNB = RC.nrmac[module_idP];
144
  NR_COMMON_channels_t *cc = &gNB->common_channels[0];
145 146 147 148
  NR_ServingCellConfigCommon_t *scc = cc->ServingCellConfigCommon;
  nfapi_nr_config_request_scf_t *cfg = &RC.nrmac[module_idP]->config[0];

  uint8_t config_index = scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->rach_ConfigGeneric.prach_ConfigurationIndex;
149
  uint8_t mu,N_dur=0,N_t_slot=0,start_symbol=0,N_RA_slot = 0;
kn.raju's avatar
kn.raju committed
150
  uint16_t format,N_RA_sfn = 0,unused_RA_occasion,repetition = 0;
151
  uint8_t num_active_ssb = 0;
152
  uint8_t max_association_period = 1;
153

kn.raju's avatar
kn.raju committed
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
  struct NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB *ssb_perRACH_OccasionAndCB_PreamblesPerSSB = scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB;

  switch (ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present){
    case NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_oneEighth:
      cc->cb_preambles_per_ssb = 4 * (ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.oneEighth + 1);
      break;
    case NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_oneFourth:
      cc->cb_preambles_per_ssb = 4 * (ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.oneFourth + 1);
      break;
    case NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_oneHalf:
      cc->cb_preambles_per_ssb = 4 * (ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.oneHalf + 1);
      break;
    case NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_one:
      cc->cb_preambles_per_ssb = 4 * (ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.one + 1);
      break;
    case NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_two:
      cc->cb_preambles_per_ssb = 4 * (ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.two + 1);
      break;
    case NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_four:
      cc->cb_preambles_per_ssb = ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.four;
      break;
    case NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_eight:
      cc->cb_preambles_per_ssb = ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.eight;
      break;
    case NR_RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_sixteen:
      cc->cb_preambles_per_ssb = ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.sixteen;
      break;
    default:
      AssertFatal(1 == 0, "Unsupported ssb_perRACH_config %d\n", ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present);
      break;
    }

186 187 188 189 190 191 192
  if (scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->msg1_SubcarrierSpacing)
    mu = *scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->msg1_SubcarrierSpacing;
  else
    mu = scc->downlinkConfigCommon->frequencyInfoDL->scs_SpecificCarrierList.list.array[0]->subcarrierSpacing;

  // prach is scheduled according to configuration index and tables 6.3.3.2.2 to 6.3.3.2.4
  get_nr_prach_occasion_info_from_index(config_index,
193 194 195 196 197 198 199 200 201 202
                                        scc->downlinkConfigCommon->frequencyInfoDL->absoluteFrequencyPointA,
                                        mu,
                                        cc->frame_type,
                                        &format,
                                        &start_symbol,
                                        &N_t_slot,
                                        &N_dur,
                                        &N_RA_slot,
                                        &N_RA_sfn,
                                        &max_association_period);
203 204

  float num_ssb_per_RO = ssb_per_rach_occasion[cfg->prach_config.ssb_per_rach.value];	
205
  uint8_t fdm = cfg->prach_config.num_prach_fd_occasions.value;
206
  uint64_t L_ssb = (((uint64_t) cfg->ssb_table.ssb_mask_list[0].ssb_mask.value)<<32) | cfg->ssb_table.ssb_mask_list[1].ssb_mask.value ;
207
  uint32_t total_RA_occasions = N_RA_sfn * N_t_slot * N_RA_slot * fdm;
208

209
  for(int i = 0;i < 64;i++) {
210
    if ((L_ssb >> (63-i)) & 0x01) { // only if the bit of L_ssb at current ssb index is 1
211
      cc->ssb_index[num_active_ssb] = i; 
212
      num_active_ssb++;
213
    }
214
  }
215

kn.raju's avatar
kn.raju committed
216 217 218 219
  cc->total_prach_occasions_per_config_period = total_RA_occasions;
  for(int i=1; (1 << (i-1)) < max_association_period; i++) {
    cc->max_association_period = (1 <<(i-1));
    total_RA_occasions = total_RA_occasions * cc->max_association_period;
220
    if(total_RA_occasions >= (int) (num_active_ssb/num_ssb_per_RO)) {
221 222 223 224
      repetition = (uint16_t)((total_RA_occasions * num_ssb_per_RO )/num_active_ssb);
      break;
    }
  }
225

226 227 228
  unused_RA_occasion = total_RA_occasions - (int)((num_active_ssb * repetition)/num_ssb_per_RO);
  cc->total_prach_occasions = total_RA_occasions - unused_RA_occasion;
  cc->num_active_ssb = num_active_ssb;
kn.raju's avatar
kn.raju committed
229

230
  LOG_I(NR_MAC,
kn.raju's avatar
kn.raju committed
231 232 233 234 235 236 237
        "Total available RO %d, num of active SSB %d: unused RO = %d association_period %u N_RA_sfn %u total_prach_occasions_per_config_period %u\n",
        cc->total_prach_occasions,
        cc->num_active_ssb,
        unused_RA_occasion,
        cc->max_association_period,
        N_RA_sfn,
        cc->total_prach_occasions_per_config_period);
238 239
}		
		
240 241
void schedule_nr_prach(module_id_t module_idP, frame_t frameP, sub_frame_t slotP)
{
242 243 244
  gNB_MAC_INST *gNB = RC.nrmac[module_idP];
  NR_COMMON_channels_t *cc = gNB->common_channels;
  NR_ServingCellConfigCommon_t *scc = cc->ServingCellConfigCommon;
245
  nfapi_nr_ul_tti_request_t *UL_tti_req = &RC.nrmac[module_idP]->UL_tti_req_ahead[0][slotP];
246
  nfapi_nr_config_request_scf_t *cfg = &RC.nrmac[module_idP]->config[0];
247

248
  if (is_nr_UL_slot(scc->tdd_UL_DL_ConfigurationCommon, slotP, cc->frame_type)) {
249

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
    uint8_t config_index = scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->rach_ConfigGeneric.prach_ConfigurationIndex;
    uint8_t mu,N_dur,N_t_slot,start_symbol = 0,N_RA_slot;
    uint16_t RA_sfn_index = -1;
    uint8_t config_period = 1;
    uint16_t format;
    int slot_index = 0;
    uint16_t prach_occasion_id = -1;

    if (scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->msg1_SubcarrierSpacing)
      mu = *scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->msg1_SubcarrierSpacing;
    else
      mu = scc->downlinkConfigCommon->frequencyInfoDL->scs_SpecificCarrierList.list.array[0]->subcarrierSpacing;

    uint8_t fdm = cfg->prach_config.num_prach_fd_occasions.value;
    // prach is scheduled according to configuration index and tables 6.3.3.2.2 to 6.3.3.2.4
    if ( get_nr_prach_info_from_index(config_index,
                                      (int)frameP,
                                      (int)slotP,
                                      scc->downlinkConfigCommon->frequencyInfoDL->absoluteFrequencyPointA,
                                      mu,
                                      cc->frame_type,
                                      &format,
                                      &start_symbol,
                                      &N_t_slot,
                                      &N_dur,
                                      &RA_sfn_index,
                                      &N_RA_slot,
                                      &config_period) ) {

      uint16_t format0 = format&0xff;      // first column of format from table
      uint16_t format1 = (format>>8)&0xff; // second column of format from table

      if (N_RA_slot > 1) { //more than 1 PRACH slot in a subframe
        if (slotP%2 == 1)
          slot_index = 1;
        else
          slot_index = 0;
      }else if (N_RA_slot <= 1) { //1 PRACH slot in a subframe
        slot_index = 0;
      }
290

291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
      UL_tti_req->SFN = frameP;
      UL_tti_req->Slot = slotP;
      for (int fdm_index=0; fdm_index < fdm; fdm_index++) { // one structure per frequency domain occasion
        for (int td_index=0; td_index<N_t_slot; td_index++) {

          prach_occasion_id = (((frameP % (cc->max_association_period * config_period))/config_period) * cc->total_prach_occasions_per_config_period) +
                              (RA_sfn_index + slot_index) * N_t_slot * fdm + td_index * fdm + fdm_index;

          if((prach_occasion_id < cc->total_prach_occasions) && (td_index == 0)){

            UL_tti_req->pdus_list[UL_tti_req->n_pdus].pdu_type = NFAPI_NR_UL_CONFIG_PRACH_PDU_TYPE;
            UL_tti_req->pdus_list[UL_tti_req->n_pdus].pdu_size = sizeof(nfapi_nr_prach_pdu_t);
            nfapi_nr_prach_pdu_t  *prach_pdu = &UL_tti_req->pdus_list[UL_tti_req->n_pdus].prach_pdu;
            memset(prach_pdu,0,sizeof(nfapi_nr_prach_pdu_t));
            UL_tti_req->n_pdus+=1;

            // filling the prach fapi structure
            prach_pdu->phys_cell_id = *scc->physCellId;
            prach_pdu->num_prach_ocas = N_t_slot;
            prach_pdu->prach_start_symbol = start_symbol;
            prach_pdu->num_ra = fdm_index;
            prach_pdu->num_cs = get_NCS(scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->rach_ConfigGeneric.zeroCorrelationZoneConfig,
                                        format0,
                                        scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->restrictedSetConfig);

316
            LOG_D(NR_MAC, "Frame %d, Slot %d: Prach Occasion id = %u  fdm index = %u start symbol = %u slot index = %u subframe index = %u \n",
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
                  frameP, slotP,
                  prach_occasion_id, prach_pdu->num_ra,
                  prach_pdu->prach_start_symbol,
                  slot_index, RA_sfn_index);
            // SCF PRACH PDU format field does not consider A1/B1 etc. possibilities
            // We added 9 = A1/B1 10 = A2/B2 11 A3/B3
            if (format1!=0xff) {
              switch(format0) {
                case 0xa1:
                  prach_pdu->prach_format = 11;
                  break;
                case 0xa2:
                  prach_pdu->prach_format = 12;
                  break;
                case 0xa3:
                  prach_pdu->prach_format = 13;
                  break;
              default:
                AssertFatal(1==0,"Only formats A1/B1 A2/B2 A3/B3 are valid for dual format");
              }
            }
            else{
              switch(format0) {
                case 0:
                  prach_pdu->prach_format = 0;
                  break;
                case 1:
                  prach_pdu->prach_format = 1;
                  break;
                case 2:
                  prach_pdu->prach_format = 2;
                  break;
                case 3:
                  prach_pdu->prach_format = 3;
                  break;
                case 0xa1:
                  prach_pdu->prach_format = 4;
                  break;
                case 0xa2:
                  prach_pdu->prach_format = 5;
                  break;
                case 0xa3:
                  prach_pdu->prach_format = 6;
                  break;
                case 0xb1:
                  prach_pdu->prach_format = 7;
                  break;
                case 0xb4:
                  prach_pdu->prach_format = 8;
                  break;
                case 0xc0:
                  prach_pdu->prach_format = 9;
                  break;
                case 0xc2:
                  prach_pdu->prach_format = 10;
                  break;
              default:
                AssertFatal(1==0,"Invalid PRACH format");
              }
            }
          }
378
        }
379
      }
380 381 382 383 384 385 386 387
    }
  }
}

void nr_schedule_msg2(uint16_t rach_frame, uint16_t rach_slot,
                      uint16_t *msg2_frame, uint16_t *msg2_slot,
                      NR_ServingCellConfigCommon_t *scc,
                      uint16_t monitoring_slot_period,
388
                      uint16_t monitoring_offset,uint8_t beam_index,
389
                      uint8_t num_active_ssb,
390
                      int16_t *tdd_beam_association){
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434

  // preferentially we schedule the msg2 in the mixed slot or in the last dl slot
  // if they are allowed by search space configuration

  uint8_t mu = *scc->ssbSubcarrierSpacing;
  uint8_t response_window = scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->rach_ConfigGeneric.ra_ResponseWindow;
  uint8_t slot_window;
  // number of mixed slot or of last dl slot if there is no mixed slot
  uint8_t last_dl_slot_period = scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofDownlinkSlots;
  // lenght of tdd period in slots
  uint8_t tdd_period_slot =  scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofDownlinkSlots + scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofUplinkSlots;
  if (scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofDownlinkSymbols == 0)
    last_dl_slot_period--;
  if ((scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofDownlinkSymbols > 0) || (scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofUplinkSymbols > 0))
    tdd_period_slot++;

  switch(response_window){
    case NR_RACH_ConfigGeneric__ra_ResponseWindow_sl1:
      slot_window = 1;
      break;
    case NR_RACH_ConfigGeneric__ra_ResponseWindow_sl2:
      slot_window = 2;
      break;
    case NR_RACH_ConfigGeneric__ra_ResponseWindow_sl4:
      slot_window = 4;
      break;
    case NR_RACH_ConfigGeneric__ra_ResponseWindow_sl8:
      slot_window = 8;
      break;
    case NR_RACH_ConfigGeneric__ra_ResponseWindow_sl10:
      slot_window = 10;
      break;
    case NR_RACH_ConfigGeneric__ra_ResponseWindow_sl20:
      slot_window = 20;
      break;
    case NR_RACH_ConfigGeneric__ra_ResponseWindow_sl40:
      slot_window = 40;
      break;
    case NR_RACH_ConfigGeneric__ra_ResponseWindow_sl80:
      slot_window = 80;
      break;
    default:
      AssertFatal(1==0,"Invalid response window value %d\n",response_window);
  }
cig's avatar
cig committed
435
  AssertFatal(slot_window<=nr_slots_per_frame[mu],"Msg2 response window needs to be lower or equal to 10ms");
436 437

  // slot and frame limit to transmit msg2 according to response window
cig's avatar
cig committed
438
  uint8_t slot_limit = (rach_slot + slot_window)%nr_slots_per_frame[mu];
Francesco Mani's avatar
Francesco Mani committed
439
  uint8_t frame_limit = (slot_limit>(rach_slot))? rach_frame : (rach_frame +1);
440

441 442 443 444 445 446
  // computing start of next period

  int FR = *scc->downlinkConfigCommon->frequencyInfoDL->frequencyBandList.list.array[0] >= 257 ? nr_FR2 : nr_FR1;

  uint8_t start_next_period = (rach_slot-(rach_slot%tdd_period_slot)+tdd_period_slot)%nr_slots_per_frame[mu];
  *msg2_slot = start_next_period + last_dl_slot_period; // initializing scheduling of slot to next mixed (or last dl) slot
rmagueta's avatar
rmagueta committed
447
  *msg2_frame = ((*msg2_slot>(rach_slot))? rach_frame : (rach_frame+1))%1024;
448 449 450 451 452

  // we can't schedule msg2 before sl_ahead since prach
  int eff_slot = *msg2_slot+(*msg2_frame-rach_frame)*nr_slots_per_frame[mu];
  if ((eff_slot-rach_slot)<=sl_ahead) {
    *msg2_slot = (*msg2_slot+tdd_period_slot)%nr_slots_per_frame[mu];
rmagueta's avatar
rmagueta committed
453
    *msg2_frame = ((*msg2_slot>(rach_slot))? rach_frame : (rach_frame+1))%1024;
454 455 456 457 458
  }
  if (FR==nr_FR2) {
    int num_tdd_period = *msg2_slot/tdd_period_slot;
    while((tdd_beam_association[num_tdd_period]!=-1)&&(tdd_beam_association[num_tdd_period]!=beam_index)) {
      *msg2_slot = (*msg2_slot+tdd_period_slot)%nr_slots_per_frame[mu];
rmagueta's avatar
rmagueta committed
459
      *msg2_frame = ((*msg2_slot>(rach_slot))? rach_frame : (rach_frame+1))%1024;
460 461 462 463 464 465
      num_tdd_period = *msg2_slot/tdd_period_slot;
    }
    if(tdd_beam_association[num_tdd_period] == -1)
      tdd_beam_association[num_tdd_period] = beam_index;
  }

466 467
  // go to previous slot if the current scheduled slot is beyond the response window
  // and if the slot is not among the PDCCH monitored ones (38.213 10.1)
Francesco Mani's avatar
Francesco Mani committed
468
  while (((*msg2_slot>slot_limit)&&(*msg2_frame>frame_limit)) || ((*msg2_frame*nr_slots_per_frame[mu]+*msg2_slot-monitoring_offset)%monitoring_slot_period !=0))  {
469
    if((*msg2_slot%tdd_period_slot) > 0)
Raphael Defosseux's avatar
Raphael Defosseux committed
470
      (*msg2_slot)--;
471 472 473
    else
      AssertFatal(1==0,"No available DL slot to schedule msg2 has been found");
  }
cig's avatar
cig committed
474
}
475

476

477 478 479 480 481
void nr_initiate_ra_proc(module_id_t module_idP,
                         int CC_id,
                         frame_t frameP,
                         sub_frame_t slotP,
                         uint16_t preamble_index,
482 483
                         uint8_t freq_index,
                         uint8_t symbol,
484 485
                         int16_t timing_offset){

486 487
  uint8_t ul_carrier_id = 0; // 0 for NUL 1 for SUL
  NR_SearchSpace_t *ss;
488

489
  uint16_t msg2_frame, msg2_slot,monitoring_slot_period,monitoring_offset;
cig's avatar
cig committed
490 491
  gNB_MAC_INST *nr_mac = RC.nrmac[module_idP];
  NR_COMMON_channels_t *cc = &nr_mac->common_channels[CC_id];
492
  NR_ServingCellConfigCommon_t *scc = cc->ServingCellConfigCommon;
kn.raju's avatar
kn.raju committed
493

494
  uint8_t total_RApreambles = MAX_NUM_NR_PRACH_PREAMBLES;
495
  uint8_t  num_ssb_per_RO = scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present;
496 497
  int pr_found;

kn.raju's avatar
kn.raju committed
498
  if( scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->totalNumberOfRA_Preambles != NULL)
499
    total_RApreambles = *scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->totalNumberOfRA_Preambles;
500

kn.raju's avatar
kn.raju committed
501 502 503 504
  if(num_ssb_per_RO > 3) { /*num of ssb per RO >= 1*/
    num_ssb_per_RO -= 3;
    total_RApreambles = total_RApreambles/num_ssb_per_RO ;
  }
505
  
506 507
  for (int i = 0; i < NR_NB_RA_PROC_MAX; i++) {
    NR_RA_t *ra = &cc->ra[i];
508
    pr_found = 0;
509
    if (ra->state == RA_IDLE) {
510 511 512 513 514 515 516 517
      for(int j = 0; j < ra->preambles.num_preambles; j++) {
        //check if the preamble received correspond to one of the listed or configured preambles
        if (preamble_index == ra->preambles.preamble_list[j]) {
          pr_found=1;
          break;
        }
      }
      if (pr_found == 0) {
518
	continue;
519
      }
520
      
521
      uint16_t ra_rnti;
522
      
523 524 525 526 527 528 529 530
      // ra_rnti from 5.1.3 in 38.321
      // FK: in case of long PRACH the phone seems to expect the subframe number instead of the slot number here.
      if (scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->prach_RootSequenceIndex.present
          == NR_RACH_ConfigCommon__prach_RootSequenceIndex_PR_l839)
        ra_rnti = 1 + symbol + (9 /*slotP*/ * 14) + (freq_index * 14 * 80) + (ul_carrier_id * 14 * 80 * 8);
      else
        ra_rnti = 1 + symbol + (slotP * 14) + (freq_index * 14 * 80) + (ul_carrier_id * 14 * 80 * 8);
      // This should be handled differently when we use the initialBWP for RA
531 532 533 534 535 536 537
      ra->bwp_id = 0;
      NR_BWP_Downlink_t *bwp=NULL;
      if (ra->CellGroup && ra->CellGroup->spCellConfig && ra->CellGroup->spCellConfig->spCellConfigDedicated &&
	  ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList) {
	bwp = ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.array[ra->bwp_id - 1];
	ra->bwp_id = 1;
      }
538
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_INITIATE_RA_PROC, 1);
539
      
540
      LOG_D(NR_MAC,
541 542 543 544 545 546 547
	    "[gNB %d][RAPROC] CC_id %d Frame %d, Slot %d  Initiating RA procedure for preamble index %d\n",
	    module_idP,
	    CC_id,
	    frameP,
	    slotP,
	    preamble_index);
      
548
      uint8_t beam_index = ssb_index_from_prach(module_idP, frameP, slotP, preamble_index, freq_index, symbol);
549
      
550 551 552 553 554
      // the UE sent a RACH either for starting RA procedure or RA procedure failed and UE retries
      if (ra->cfra) {
        // if the preamble received correspond to one of the listed
        if (!(preamble_index == ra->preambles.preamble_list[beam_index])) {
          LOG_E(
555
              NR_MAC,
556 557 558 559 560
              "[gNB %d][RAPROC] FAILURE: preamble %d does not correspond to any of the ones in rach_ConfigDedicated\n",
              module_idP,
              preamble_index);
          continue; // if the PRACH preamble does not correspond to any of the ones sent through RRC abort RA proc
        }
Francesco Mani's avatar
Francesco Mani committed
561
      }
562
      LOG_D(NR_MAC, "Frame %d, Slot %d: Activating RA process \n", frameP, slotP);
563 564 565 566
      ra->state = Msg2;
      ra->timing_offset = timing_offset;
      ra->preamble_slot = slotP;

567 568 569
      struct NR_PDCCH_ConfigCommon__commonSearchSpaceList *commonSearchSpaceList = bwp ? 
	bwp->bwp_Common->pdcch_ConfigCommon->choice.setup->commonSearchSpaceList:
	scc->downlinkConfigCommon->initialDownlinkBWP->pdcch_ConfigCommon->choice.setup->commonSearchSpaceList;
570
      AssertFatal(commonSearchSpaceList->list.count > 0, "common SearchSpace list has 0 elements\n");
571

572 573 574
      // Common searchspace list
      for (int i = 0; i < commonSearchSpaceList->list.count; i++) {
        ss = commonSearchSpaceList->list.array[i];
575 576 577
        if (ss->searchSpaceId == (bwp ? 
				  *bwp->bwp_Common->pdcch_ConfigCommon->choice.setup->ra_SearchSpace :
				  *scc->downlinkConfigCommon->initialDownlinkBWP->pdcch_ConfigCommon->choice.setup->ra_SearchSpace))
578
          ra->ra_ss = ss;
Francesco Mani's avatar
Francesco Mani committed
579
      }
580 581 582 583 584 585 586 587 588 589 590 591

      // retrieving ra pdcch monitoring period and offset
      find_monitoring_periodicity_offset_common(ra->ra_ss, &monitoring_slot_period, &monitoring_offset);

      nr_schedule_msg2(frameP,
                       slotP,
                       &msg2_frame,
                       &msg2_slot,
                       scc,
                       monitoring_slot_period,
                       monitoring_offset,
                       beam_index,
592 593
                       cc->num_active_ssb,
                       nr_mac->tdd_beam_association);
594 595 596 597

      ra->Msg2_frame = msg2_frame;
      ra->Msg2_slot = msg2_slot;

598
      LOG_D(NR_MAC, "%s() Msg2[%04d%d] SFN/SF:%04d%d\n", __FUNCTION__, ra->Msg2_frame, ra->Msg2_slot, frameP, slotP);
599 600

      int loop = 0;
601 602
      // This condition allows for the usage of a preconfigured rnti for the first UE
      if (!ra->cfra || ra->rnti == 0) {
603 604 605 606 607 608 609
        do {
          ra->rnti = (taus() % 65518) + 1;
          loop++;
        } while (loop != 100
                 && !((find_nr_UE_id(module_idP, ra->rnti) == -1) && (find_nr_RA_id(module_idP, CC_id, ra->rnti) == -1)
                      && ra->rnti >= 1 && ra->rnti <= 65519));
        if (loop == 100) {
610
          LOG_E(NR_MAC, "%s:%d:%s: [RAPROC] initialisation random access aborted\n", __FILE__, __LINE__, __FUNCTION__);
611 612 613
          abort();
        }
      }
614

615 616 617 618
      ra->RA_rnti = ra_rnti;
      ra->preamble_index = preamble_index;
      ra->beam_id = beam_index;

619
      LOG_D(NR_MAC,
620 621 622 623 624 625 626 627 628 629 630
            "[gNB %d][RAPROC] CC_id %d Frame %d Activating Msg2 generation in frame %d, slot %d using RA rnti %x SSB "
            "index %u\n",
            module_idP,
            CC_id,
            frameP,
            ra->Msg2_frame,
            ra->Msg2_slot,
            ra->RA_rnti,
            cc->ssb_index[beam_index]);

      return;
cig's avatar
cig committed
631
    }
632
  }
633
  LOG_E(NR_MAC, "[gNB %d][RAPROC] FAILURE: CC_id %d Frame %d initiating RA procedure for preamble index %d\n", module_idP, CC_id, frameP, preamble_index);
634

cig's avatar
cig committed
635
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_INITIATE_RA_PROC, 0);
636 637
}

638
void nr_schedule_RA(module_id_t module_idP, frame_t frameP, sub_frame_t slotP)
639 640 641 642 643 644 645 646
  {
    gNB_MAC_INST *mac = RC.nrmac[module_idP];

    start_meas(&mac->schedule_ra);
    for (int CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
      NR_COMMON_channels_t *cc = &mac->common_channels[CC_id];
      for (int i = 0; i < NR_NB_RA_PROC_MAX; i++) {
        NR_RA_t *ra = &cc->ra[i];
647
        LOG_D(NR_MAC, "RA[state:%d]\n", ra->state);
648 649 650 651 652
        switch (ra->state) {
          case Msg2:
            nr_generate_Msg2(module_idP, CC_id, frameP, slotP, ra);
            break;
          case Msg4:
653
            nr_generate_Msg4(module_idP, CC_id, frameP, slotP, ra);
654 655
            break;
          case WAIT_Msg4_ACK:
656
            nr_check_Msg4_Ack(module_idP, CC_id, frameP, slotP, ra);
657 658 659 660
            break;
          default:
            break;
        }
661 662
      }
    }
663
    stop_meas(&mac->schedule_ra);
cig's avatar
cig committed
664
  }
665

666 667 668
void nr_get_Msg3alloc(module_id_t module_id,
                      int CC_id,
                      NR_ServingCellConfigCommon_t *scc,
669
                      NR_BWP_Uplink_t *ubwp,
670 671
                      sub_frame_t current_slot,
                      frame_t current_frame,
rmagueta's avatar
rmagueta committed
672 673
                      NR_RA_t *ra,
                      int16_t *tdd_beam_association) {
674

675
    // msg3 is schedulend in mixed slot in the following TDD period
rmagueta's avatar
rmagueta committed
676

677
    uint16_t msg3_nb_rb = 8 + sizeof(NR_MAC_SUBHEADER_SHORT) + sizeof(NR_MAC_SUBHEADER_SHORT); // sdu has 6 or 8 bytes
678

679 680 681
    int mu = ubwp ? 
      ubwp->bwp_Common->genericParameters.subcarrierSpacing :
      scc->uplinkConfigCommon->initialUplinkBWP->genericParameters.subcarrierSpacing;
682 683
    int StartSymbolIndex, NrOfSymbols, startSymbolAndLength, temp_slot;
    ra->Msg3_tda_id = 16; // initialization to a value above limit
684

685 686 687 688 689 690
    NR_PUSCH_TimeDomainResourceAllocationList_t *pusch_TimeDomainAllocationList= ubwp ? 
      ubwp->bwp_Common->pusch_ConfigCommon->choice.setup->pusch_TimeDomainAllocationList:
      scc->uplinkConfigCommon->initialUplinkBWP->pusch_ConfigCommon->choice.setup->pusch_TimeDomainAllocationList;

    for (int i=0; i<pusch_TimeDomainAllocationList->list.count; i++) {
      startSymbolAndLength = pusch_TimeDomainAllocationList->list.array[i]->startSymbolAndLength;
691 692 693 694 695 696
      SLIV2SL(startSymbolAndLength, &StartSymbolIndex, &NrOfSymbols);
      // we want to transmit in the uplink symbols of mixed slot
      if (NrOfSymbols == scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofUplinkSymbols) {
        ra->Msg3_tda_id = i;
        break;
      }
697
    }
698
    AssertFatal(ra->Msg3_tda_id<16,"Unable to find Msg3 time domain allocation in list\n");
699

700
    uint8_t k2 = *pusch_TimeDomainAllocationList->list.array[ra->Msg3_tda_id]->k2;
701

702 703 704 705 706
    temp_slot = current_slot + k2 + DELTA[mu]; // msg3 slot according to 8.3 in 38.213
    ra->Msg3_slot = temp_slot%nr_slots_per_frame[mu];
    if (nr_slots_per_frame[mu]>temp_slot)
      ra->Msg3_frame = current_frame;
    else
rmagueta's avatar
rmagueta committed
707
      ra->Msg3_frame = (current_frame + (temp_slot/nr_slots_per_frame[mu]))%1024;
708

709 710 711 712 713 714 715 716 717 718 719 720
  // beam association for FR2
  if (*scc->downlinkConfigCommon->frequencyInfoDL->frequencyBandList.list.array[0] >= 257) {
    uint8_t tdd_period_slot =  scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofDownlinkSlots + scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofUplinkSlots;
    if ((scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofDownlinkSymbols > 0) || (scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofUplinkSymbols > 0))
      tdd_period_slot++;
    int num_tdd_period = ra->Msg3_slot/tdd_period_slot;
    if((tdd_beam_association[num_tdd_period]!=-1)&&(tdd_beam_association[num_tdd_period]!=ra->beam_id))
      AssertFatal(1==0,"Cannot schedule MSG3\n");
    else
      tdd_beam_association[num_tdd_period] = ra->beam_id;
  }

721
  LOG_D(NR_MAC, "[RAPROC] Msg3 slot %d: current slot %u Msg3 frame %u k2 %u Msg3_tda_id %u start symbol index %u\n", ra->Msg3_slot, current_slot, ra->Msg3_frame, k2,ra->Msg3_tda_id, StartSymbolIndex);
722
  uint16_t *vrb_map_UL =
cig's avatar
cig committed
723
      &RC.nrmac[module_id]->common_channels[CC_id].vrb_map_UL[ra->Msg3_slot * MAX_BWP_SIZE];
724 725 726 727
  const uint16_t bwpSize = NRRIV2BW(ubwp ? 
				    ubwp->bwp_Common->genericParameters.locationAndBandwidth :
				    scc->uplinkConfigCommon->initialUplinkBWP->genericParameters.locationAndBandwidth, 
				    MAX_BWP_SIZE);
rmagueta's avatar
rmagueta committed
728

729
    /* search msg3_nb_rb free RBs */
730 731
  int rbSize = 0;
  int rbStart = 0;
rmagueta's avatar
rmagueta committed
732
  while (rbSize < msg3_nb_rb) {
733 734 735 736
    rbStart += rbSize; /* last iteration rbSize was not enough, skip it */
    rbSize = 0;
    while (rbStart < bwpSize && vrb_map_UL[rbStart])
      rbStart++;
rmagueta's avatar
rmagueta committed
737
    AssertFatal(rbStart < bwpSize - msg3_nb_rb, "no space to allocate Msg 3 for RA!\n");
738 739
    while (rbStart + rbSize < bwpSize
           && !vrb_map_UL[rbStart + rbSize]
rmagueta's avatar
rmagueta committed
740
           && rbSize < msg3_nb_rb)
741
      rbSize++;
742
  }
rmagueta's avatar
rmagueta committed
743
  ra->msg3_nb_rb = msg3_nb_rb;
744
  ra->msg3_first_rb = rbStart;
745 746
}

747 748
void nr_add_msg3(module_id_t module_idP, int CC_id, frame_t frameP, sub_frame_t slotP, NR_RA_t *ra, uint8_t *RAR_pdu)
{
cig's avatar
cig committed
749 750 751 752
  gNB_MAC_INST                                   *mac = RC.nrmac[module_idP];
  NR_COMMON_channels_t                            *cc = &mac->common_channels[CC_id];
  NR_ServingCellConfigCommon_t                   *scc = cc->ServingCellConfigCommon;

753
  if (ra->state == RA_IDLE) {
754
    LOG_W(NR_MAC,"RA is not active for RA %X. skipping msg3 scheduling\n", ra->rnti);
755 756
    return;
  }
cig's avatar
cig committed
757

758
  uint16_t *vrb_map_UL =
759
      &RC.nrmac[module_idP]->common_channels[CC_id].vrb_map_UL[ra->Msg3_slot * MAX_BWP_SIZE];
760 761 762 763 764 765 766 767 768
  for (int i = 0; i < ra->msg3_nb_rb; ++i) {
    AssertFatal(!vrb_map_UL[i + ra->msg3_first_rb],
                "RB %d in %4d.%2d is already taken, cannot allocate Msg3!\n",
                i + ra->msg3_first_rb,
                ra->Msg3_frame,
                ra->Msg3_slot);
    vrb_map_UL[i + ra->msg3_first_rb] = 1;
  }

769
  LOG_D(NR_MAC, "[gNB %d][RAPROC] Frame %d, Subframe %d : CC_id %d RA is active, Msg3 in (%d,%d)\n", module_idP, frameP, slotP, CC_id, ra->Msg3_frame, ra->Msg3_slot);
770

771 772 773 774 775 776 777 778 779 780 781
  nfapi_nr_ul_tti_request_t *future_ul_tti_req = &RC.nrmac[module_idP]->UL_tti_req_ahead[CC_id][ra->Msg3_slot];
  AssertFatal(future_ul_tti_req->SFN == ra->Msg3_frame
              && future_ul_tti_req->Slot == ra->Msg3_slot,
              "future UL_tti_req's frame.slot %d.%d does not match PUSCH %d.%d\n",
              future_ul_tti_req->SFN,
              future_ul_tti_req->Slot,
              ra->Msg3_frame,
              ra->Msg3_slot);
  future_ul_tti_req->pdus_list[future_ul_tti_req->n_pdus].pdu_type = NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE;
  future_ul_tti_req->pdus_list[future_ul_tti_req->n_pdus].pdu_size = sizeof(nfapi_nr_pusch_pdu_t);
  nfapi_nr_pusch_pdu_t *pusch_pdu = &future_ul_tti_req->pdus_list[future_ul_tti_req->n_pdus].pusch_pdu;
cig's avatar
cig committed
782
  memset(pusch_pdu, 0, sizeof(nfapi_nr_pusch_pdu_t));
783
  future_ul_tti_req->n_pdus += 1;
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
  int ibwp_size  = NRRIV2BW(scc->uplinkConfigCommon->initialUplinkBWP->genericParameters.locationAndBandwidth, MAX_BWP_SIZE);
  int ibwp_start = NRRIV2PRBOFFSET(scc->uplinkConfigCommon->initialUplinkBWP->genericParameters.locationAndBandwidth, MAX_BWP_SIZE);
  int abwp_size = ibwp_size;
  int abwp_start = ibwp_start;
  int scs = scc->uplinkConfigCommon->initialUplinkBWP->genericParameters.subcarrierSpacing;
  int fh = 0;
  int startSymbolAndLength = scc->uplinkConfigCommon->initialUplinkBWP->pusch_ConfigCommon->choice.setup->pusch_TimeDomainAllocationList->list.array[ra->Msg3_tda_id]->startSymbolAndLength;

  if (ra->CellGroup) {
    AssertFatal(ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count == 1,
		"downlinkBWP_ToAddModList has %d BWP!\n", ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count);
    NR_BWP_Uplink_t *ubwp = ra->CellGroup->spCellConfig->spCellConfigDedicated->uplinkConfig->uplinkBWP_ToAddModList->list.array[ra->bwp_id - 1];


    startSymbolAndLength = ubwp->bwp_Common->pusch_ConfigCommon->choice.setup->pusch_TimeDomainAllocationList->list.array[ra->Msg3_tda_id]->startSymbolAndLength;
    abwp_size  = NRRIV2BW(ubwp->bwp_Common->genericParameters.locationAndBandwidth, MAX_BWP_SIZE);
    abwp_start = NRRIV2PRBOFFSET(ubwp->bwp_Common->genericParameters.locationAndBandwidth, MAX_BWP_SIZE);
    scs = ubwp->bwp_Common->genericParameters.subcarrierSpacing;
    fh = ubwp->bwp_Dedicated->pusch_Config->choice.setup->frequencyHopping ? 1 : 0;

  }
805

806
  LOG_D(NR_MAC, "Frame %d, Subframe %d Adding Msg3 UL Config Request for (%d,%d) : (%d,%d,%d) for rnti: %d\n",
807 808 809 810 811 812 813 814 815
	frameP,
	slotP,
	ra->Msg3_frame,
	ra->Msg3_slot,
	ra->msg3_nb_rb,
	ra->msg3_first_rb,
	ra->msg3_round,
	ra->rnti);
  
816 817 818
  int start_symbol_index,nr_of_symbols;
  SLIV2SL(startSymbolAndLength, &start_symbol_index, &nr_of_symbols);

cig's avatar
cig committed
819 820 821
  pusch_pdu->pdu_bit_map = PUSCH_PDU_BITMAP_PUSCH_DATA;
  pusch_pdu->rnti = ra->rnti;
  pusch_pdu->handle = 0;
822

823 824 825 826 827
  if ((ibwp_start < abwp_start) || (ibwp_size > abwp_size))
    pusch_pdu->bwp_start = abwp_start;
  else
    pusch_pdu->bwp_start = ibwp_start;
  pusch_pdu->bwp_size = ibwp_size;
828
  pusch_pdu->subcarrier_spacing = scs; 
cig's avatar
cig committed
829
  pusch_pdu->cyclic_prefix = 0;
830
  pusch_pdu->mcs_index = 0;
cig's avatar
cig committed
831 832 833
  pusch_pdu->mcs_table = 0;
  pusch_pdu->target_code_rate = nr_get_code_rate_ul(pusch_pdu->mcs_index,pusch_pdu->mcs_table);
  pusch_pdu->qam_mod_order = nr_get_Qm_ul(pusch_pdu->mcs_index,pusch_pdu->mcs_table);
834 835 836 837 838
  if (scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup->msg3_transformPrecoder == NULL)
    pusch_pdu->transform_precoding = 1;
  else
    pusch_pdu->transform_precoding = 0;
  pusch_pdu->data_scrambling_id = *scc->physCellId;
cig's avatar
cig committed
839
  pusch_pdu->nrOfLayers = 1;
840
  pusch_pdu->ul_dmrs_symb_pos = 1<<start_symbol_index; // ok for now but use fill dmrs mask later
cig's avatar
cig committed
841
  pusch_pdu->dmrs_config_type = 0;
842
  pusch_pdu->ul_dmrs_scrambling_id = *scc->physCellId; //If provided and the PUSCH is not a msg3 PUSCH, otherwise, L2 should set this to physical cell id.
cig's avatar
cig committed
843
  pusch_pdu->scid = 0; //DMRS sequence initialization [TS38.211, sec 6.4.1.1.1]. Should match what is sent in DCI 0_1, otherwise set to 0.
844 845
  pusch_pdu->dmrs_ports = 1;  // 6.2.2 in 38.214 only port 0 to be used
  pusch_pdu->num_dmrs_cdm_grps_no_data = 2;  // no data in dmrs symbols as in 6.2.2 in 38.214
cig's avatar
cig committed
846
  pusch_pdu->resource_alloc = 1; //type 1
847 848
  //pusch_pdu->rb_start = ra->msg3_first_rb + ibwp_start - abwp_start; // as for 6.3.1.7 in 38.211
  pusch_pdu->rb_start = ra->msg3_first_rb;
849 850 851 852
  if (ra->msg3_nb_rb > pusch_pdu->bwp_size)
    AssertFatal(1==0,"MSG3 allocated number of RBs exceed the BWP size\n");
  else
    pusch_pdu->rb_size = ra->msg3_nb_rb;
cig's avatar
cig committed
853
  pusch_pdu->vrb_to_prb_mapping = 0;
854 855

  pusch_pdu->frequency_hopping = fh;
cig's avatar
cig committed
856 857 858
  //pusch_pdu->tx_direct_current_location;//The uplink Tx Direct Current location for the carrier. Only values in the value range of this field between 0 and 3299, which indicate the subcarrier index within the carrier corresponding 1o the numerology of the corresponding uplink BWP and value 3300, which indicates "Outside the carrier" and value 3301, which indicates "Undetermined position within the carrier" are used. [TS38.331, UplinkTxDirectCurrentBWP IE]
  pusch_pdu->uplink_frequency_shift_7p5khz = 0;
  //Resource Allocation in time domain
859 860
  pusch_pdu->start_symbol_index = start_symbol_index;
  pusch_pdu->nr_of_symbols = nr_of_symbols;
cig's avatar
cig committed
861
  //Optional Data only included if indicated in pduBitmap
862
  pusch_pdu->pusch_data.rv_index = 0;  // 8.3 in 38.213
cig's avatar
cig committed
863
  pusch_pdu->pusch_data.harq_process_id = 0;
864 865 866
  pusch_pdu->pusch_data.new_data_indicator = 1; // new data
  pusch_pdu->pusch_data.num_cb = 0;
  pusch_pdu->pusch_data.tb_size = nr_compute_tbs(pusch_pdu->qam_mod_order,
cig's avatar
cig committed
867 868 869
                                                 pusch_pdu->target_code_rate,
                                                 pusch_pdu->rb_size,
                                                 pusch_pdu->nr_of_symbols,
870
                                                 12, // nb dmrs set for no data in dmrs symbol
cig's avatar
cig committed
871
                                                 0, //nb_rb_oh
872
                                                 0, // to verify tb scaling
873 874 875
                                                 pusch_pdu->nrOfLayers = 1)>>3;

  // calling function to fill rar message
876
  nr_fill_rar(module_idP, ra, RAR_pdu, pusch_pdu);
cig's avatar
cig committed
877 878
}

879
void nr_generate_Msg2(module_id_t module_idP, int CC_id, frame_t frameP, sub_frame_t slotP, NR_RA_t *ra)
880
{
881

rmagueta's avatar
rmagueta committed
882 883
  gNB_MAC_INST *nr_mac = RC.nrmac[module_idP];
  NR_COMMON_channels_t *cc = &nr_mac->common_channels[CC_id];
cig's avatar
cig committed
884

rmagueta's avatar
rmagueta committed
885
  if ((ra->Msg2_frame == frameP) && (ra->Msg2_slot == slotP)) {
886

887
    uint8_t time_domain_assignment = 3;
rmagueta's avatar
rmagueta committed
888
    uint8_t mcsIndex = 0;
889
    int rbStart = 0;
890
    int rbSize = 8;
891 892


rmagueta's avatar
rmagueta committed
893
    NR_ServingCellConfigCommon_t *scc = cc->ServingCellConfigCommon;
894 895
    NR_SearchSpace_t *ss = ra->ra_ss;

896
    long BWPSize  = NRRIV2BW(scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.locationAndBandwidth, MAX_BWP_SIZE);
rmagueta's avatar
rmagueta committed
897 898 899

    NR_BWP_Downlink_t *bwp = NULL;
    NR_ControlResourceSet_t *coreset = NULL;
900 901
    NR_BWP_t *genericParameters = NULL;
    NR_PDSCH_TimeDomainResourceAllocationList_t *pdsch_TimeDomainAllocationList=NULL;
902
    long BWPStart = 0;
903 904 905 906 907 908 909 910 911

    if (ra->CellGroup &&
	ra->CellGroup->spCellConfig &&
	ra->CellGroup->spCellConfig->spCellConfigDedicated &&
	ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList &&
	ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.array[ra->bwp_id-1]) {
      bwp = ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.array[ra->bwp_id-1];
      genericParameters = &bwp->bwp_Common->genericParameters;
      pdsch_TimeDomainAllocationList = bwp->bwp_Common->pdsch_ConfigCommon->choice.setup->pdsch_TimeDomainAllocationList;
rmagueta's avatar
rmagueta committed
912
    }
913 914 915
    else {
      genericParameters= &scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters;
      pdsch_TimeDomainAllocationList = scc->downlinkConfigCommon->initialDownlinkBWP->pdsch_ConfigCommon->choice.setup->pdsch_TimeDomainAllocationList;
rmagueta's avatar
rmagueta committed
916
    }
917 918 919 920
    BWPStart = NRRIV2PRBOFFSET(genericParameters->locationAndBandwidth, MAX_BWP_SIZE);
    ss = ra->ra_ss;
    coreset = get_coreset(scc,bwp, ss, NR_SearchSpace__searchSpaceType_PR_common);
    if (coreset == NULL) coreset = nr_mac->sched_ctrlCommon->coreset;
cig's avatar
cig committed
921

922
    uint16_t *vrb_map = cc[CC_id].vrb_map;
923
    for (int i = 0; (i < rbSize) && (rbStart <= (BWPSize - rbSize)); i++) {
924 925 926 927 928
      if (vrb_map[rbStart + i]) {
        rbStart += i;
        i = 0;
      }
    }
rmagueta's avatar
rmagueta committed
929

930
    if (rbStart > (BWPSize - rbSize)) {
rmagueta's avatar
rmagueta committed
931
      LOG_E(NR_MAC, "%s(): cannot find free vrb_map for RA RNTI %04x!\n", __func__, ra->RA_rnti);
932 933 934
      return;
    }

935
    // Checking if the DCI allocation is feasible in current subframe
cig's avatar
cig committed
936
    nfapi_nr_dl_tti_request_body_t *dl_req = &nr_mac->DL_req[CC_id].dl_tti_request_body;
937
    if (dl_req->nPDUs > NFAPI_NR_MAX_DL_TTI_PDUS - 2) {
938
      LOG_I(NR_MAC, "[RAPROC] Subframe %d: FAPI DL structure is full, skip scheduling UE %d\n", slotP, ra->RA_rnti);
939 940 941
      return;
    }

rmagueta's avatar
rmagueta committed
942 943
    uint8_t aggregation_level;
    uint8_t nr_of_candidates;
944
    find_aggregation_candidates(&aggregation_level, &nr_of_candidates, ss);
rmagueta's avatar
rmagueta committed
945
    int CCEIndex = allocate_nr_CCEs(nr_mac, bwp, coreset, aggregation_level,0,0,nr_of_candidates);
946
    if (CCEIndex < 0) {
947
      LOG_E(NR_MAC, "%s(): cannot find free CCE for RA RNTI %04x!\n", __func__, ra->rnti);
948 949 950
      return;
    }

rmagueta's avatar
rmagueta committed
951 952
    // Calculate number of symbols
    int startSymbolIndex, nrOfSymbols;
953
    const int startSymbolAndLength = pdsch_TimeDomainAllocationList->list.array[time_domain_assignment]->startSymbolAndLength;
rmagueta's avatar
rmagueta committed
954 955 956
    SLIV2SL(startSymbolAndLength, &startSymbolIndex, &nrOfSymbols);
    AssertFatal(startSymbolIndex >= 0, "StartSymbolIndex is negative\n");

957
    LOG_D(MAC,"Msg2 startSymbolIndex.nrOfSymbols %d.%d\n",startSymbolIndex,nrOfSymbols);
rmagueta's avatar
rmagueta committed
958

rmagueta's avatar
rmagueta committed
959 960
    // look up the PDCCH PDU for this CC, BWP, and CORESET. If it does not exist, create it. This is especially
    // important if we have multiple RAs, and the DLSCH has to reuse them, so we need to mark them
961
    const int bwpid = bwp ? bwp->bwp_Id : 0;
962
    const int coresetid = coreset->controlResourceSetId;
963
    nfapi_nr_dl_tti_pdcch_pdu_rel15_t *pdcch_pdu_rel15 = nr_mac->pdcch_pdu_idx[CC_id][ra->bwp_id][coresetid];
964 965 966 967 968 969 970 971
    if (!pdcch_pdu_rel15) {
      nfapi_nr_dl_tti_request_pdu_t *dl_tti_pdcch_pdu = &dl_req->dl_tti_pdu_list[dl_req->nPDUs];
      memset(dl_tti_pdcch_pdu, 0, sizeof(nfapi_nr_dl_tti_request_pdu_t));
      dl_tti_pdcch_pdu->PDUType = NFAPI_NR_DL_TTI_PDCCH_PDU_TYPE;
      dl_tti_pdcch_pdu->PDUSize = (uint8_t)(2 + sizeof(nfapi_nr_dl_tti_pdcch_pdu));
      dl_req->nPDUs += 1;
      pdcch_pdu_rel15 = &dl_tti_pdcch_pdu->pdcch_pdu.pdcch_pdu_rel15;
      nr_configure_pdcch(pdcch_pdu_rel15, ss, coreset, scc, bwp);
972
      nr_mac->pdcch_pdu_idx[CC_id][ra->bwp_id][coresetid] = pdcch_pdu_rel15;
973
    }
rmagueta's avatar
rmagueta committed
974

975
    nfapi_nr_dl_tti_request_pdu_t *dl_tti_pdsch_pdu = &dl_req->dl_tti_pdu_list[dl_req->nPDUs];
cig's avatar
cig committed
976 977 978
    memset((void *)dl_tti_pdsch_pdu,0,sizeof(nfapi_nr_dl_tti_request_pdu_t));
    dl_tti_pdsch_pdu->PDUType = NFAPI_NR_DL_TTI_PDSCH_PDU_TYPE;
    dl_tti_pdsch_pdu->PDUSize = (uint8_t)(2+sizeof(nfapi_nr_dl_tti_pdsch_pdu));
979
    dl_req->nPDUs+=1;
cig's avatar
cig committed
980
    nfapi_nr_dl_tti_pdsch_pdu_rel15_t *pdsch_pdu_rel15 = &dl_tti_pdsch_pdu->pdsch_pdu.pdsch_pdu_rel15;
981

rmagueta's avatar
rmagueta committed
982 983
    LOG_I(NR_MAC,"[gNB %d][RAPROC] CC_id %d Frame %d, slotP %d: Generating RA-Msg2 DCI, rnti 0x%x, state %d\n",
          module_idP, CC_id, frameP, slotP, ra->RA_rnti, ra->state);
cig's avatar
cig committed
984

rmagueta's avatar
rmagueta committed
985 986
    // SCF222: PDU index incremented for each PDSCH PDU sent in TX control message. This is used to associate control
    // information to data and is reset every slot.
987
    const int pduindex = nr_mac->pdu_index[CC_id]++;
988

rmagueta's avatar
rmagueta committed
989
    uint8_t mcsTableIdx = 0;
990 991 992 993 994
    if (bwp &&
	bwp->bwp_Dedicated &&
	bwp->bwp_Dedicated->pdsch_Config &&
	bwp->bwp_Dedicated->pdsch_Config->choice.setup &&
	bwp->bwp_Dedicated->pdsch_Config->choice.setup->mcs_Table) {
rmagueta's avatar
rmagueta committed
995 996 997 998 999
      if (*bwp->bwp_Dedicated->pdsch_Config->choice.setup->mcs_Table == 0)
        mcsTableIdx = 1;
      else
        mcsTableIdx = 2;
    }
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
    else mcsTableIdx = 0;

    int dmrsConfigType=0;
    if (bwp &&
	bwp->bwp_Dedicated &&
	bwp->bwp_Dedicated->pdsch_Config &&
	bwp->bwp_Dedicated->pdsch_Config->choice.setup &&
	bwp->bwp_Dedicated->pdsch_Config->choice.setup->dmrs_DownlinkForPDSCH_MappingTypeA &&
	bwp->bwp_Dedicated->pdsch_Config->choice.setup->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup &&
	bwp->bwp_Dedicated->pdsch_Config->choice.setup->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_Type)
      dmrsConfigType = 1;
1011

rmagueta's avatar
rmagueta committed
1012 1013
    pdsch_pdu_rel15->pduBitmap = 0;
    pdsch_pdu_rel15->rnti = ra->RA_rnti;
1014
    pdsch_pdu_rel15->pduIndex = pduindex;
1015 1016
    pdsch_pdu_rel15->BWPSize  = BWPSize;
    pdsch_pdu_rel15->BWPStart = BWPStart;
1017
    pdsch_pdu_rel15->SubcarrierSpacing = genericParameters->subcarrierSpacing;
cig's avatar
cig committed
1018 1019
    pdsch_pdu_rel15->CyclicPrefix = 0;
    pdsch_pdu_rel15->NrOfCodewords = 1;
rmagueta's avatar
rmagueta committed
1020
    pdsch_pdu_rel15->targetCodeRate[0] = nr_get_code_rate_dl(mcsIndex,mcsTableIdx);
cig's avatar
cig committed
1021 1022
    pdsch_pdu_rel15->qamModOrder[0] = 2;
    pdsch_pdu_rel15->mcsIndex[0] = mcsIndex;
rmagueta's avatar
rmagueta committed
1023
    pdsch_pdu_rel15->mcsTable[0] = mcsTableIdx;
cig's avatar
cig committed
1024 1025 1026 1027 1028
    pdsch_pdu_rel15->rvIndex[0] = 0;
    pdsch_pdu_rel15->dataScramblingId = *scc->physCellId;
    pdsch_pdu_rel15->nrOfLayers = 1;
    pdsch_pdu_rel15->transmissionScheme = 0;
    pdsch_pdu_rel15->refPoint = 0;
1029
    pdsch_pdu_rel15->dmrsConfigType = dmrsConfigType;
cig's avatar
cig committed
1030 1031
    pdsch_pdu_rel15->dlDmrsScramblingId = *scc->physCellId;
    pdsch_pdu_rel15->SCID = 0;
1032
    pdsch_pdu_rel15->numDmrsCdmGrpsNoData = nrOfSymbols <=2 ? 1 : 2;
cig's avatar
cig committed
1033 1034
    pdsch_pdu_rel15->dmrsPorts = 1;
    pdsch_pdu_rel15->resourceAlloc = 1;
1035 1036
    pdsch_pdu_rel15->rbStart = rbStart;
    pdsch_pdu_rel15->rbSize = rbSize;
rmagueta's avatar
rmagueta committed
1037
    pdsch_pdu_rel15->VRBtoPRBMapping = 0;
rmagueta's avatar
rmagueta committed
1038 1039
    pdsch_pdu_rel15->StartSymbolIndex = startSymbolIndex;
    pdsch_pdu_rel15->NrOfSymbols = nrOfSymbols;
1040
    pdsch_pdu_rel15->dlDmrsSymbPos = fill_dmrs_mask(NULL,
rmagueta's avatar
rmagueta committed
1041 1042 1043
                                                    nr_mac->common_channels->ServingCellConfigCommon->dmrs_TypeA_Position,
                                                    nrOfSymbols,
                                                    startSymbolIndex);
cig's avatar
cig committed
1044

rmagueta's avatar
rmagueta committed
1045 1046 1047
    int x_Overhead = 0;
    uint8_t tb_scaling = 0;
    nr_get_tbs_dl(&dl_tti_pdsch_pdu->pdsch_pdu, x_Overhead, pdsch_pdu_rel15->numDmrsCdmGrpsNoData, tb_scaling);
cig's avatar
cig committed
1048

rmagueta's avatar
rmagueta committed
1049
    // Fill PDCCH DL DCI PDU
1050 1051
    nfapi_nr_dl_dci_pdu_t *dci_pdu = &pdcch_pdu_rel15->dci_pdu[pdcch_pdu_rel15->numDlDci];
    pdcch_pdu_rel15->numDlDci++;
rmagueta's avatar
rmagueta committed
1052
    dci_pdu->RNTI = ra->RA_rnti;
1053 1054 1055 1056 1057 1058 1059 1060 1061
    dci_pdu->ScramblingId = *scc->physCellId;
    dci_pdu->ScramblingRNTI = 0;
    dci_pdu->AggregationLevel = aggregation_level;
    dci_pdu->CceIndex = CCEIndex;
    dci_pdu->beta_PDCCH_1_0 = 0;
    dci_pdu->powerControlOffsetSS = 1;

    dci_pdu_rel15_t dci_payload;
    dci_payload.frequency_domain_assignment.val = PRBalloc_to_locationandbandwidth0(pdsch_pdu_rel15->rbSize,
rmagueta's avatar
rmagueta committed
1062 1063
                                                                                    pdsch_pdu_rel15->rbStart,
                                                                                    pdsch_pdu_rel15->BWPSize);
1064 1065 1066
    LOG_D(MAC,"Msg2 rbSize.rbStart.BWPsize %d.%d.%d\n",pdsch_pdu_rel15->rbSize,
	  pdsch_pdu_rel15->rbStart,
	  pdsch_pdu_rel15->BWPSize);
rmagueta's avatar
rmagueta committed
1067

1068 1069 1070
    dci_payload.time_domain_assignment.val = time_domain_assignment;
    dci_payload.vrb_to_prb_mapping.val = 0;
    dci_payload.mcs = pdsch_pdu_rel15->mcsIndex[0];
rmagueta's avatar
rmagueta committed
1071
    dci_payload.tb_scaling = tb_scaling;
1072

rmagueta's avatar
rmagueta committed
1073
    LOG_D(NR_MAC,
1074
          "[RAPROC] DCI type 1 payload: freq_alloc %d (%d,%d,%d), time_alloc %d, vrb to prb %d, mcs %d tb_scaling %d \n",
1075
          dci_payload.frequency_domain_assignment.val,
1076 1077
          pdsch_pdu_rel15->rbStart,
          pdsch_pdu_rel15->rbSize,
rmagueta's avatar
rmagueta committed
1078
          pdsch_pdu_rel15->BWPSize,
1079 1080 1081 1082
          dci_payload.time_domain_assignment.val,
          dci_payload.vrb_to_prb_mapping.val,
          dci_payload.mcs,
          dci_payload.tb_scaling);
cig's avatar
cig committed
1083

rmagueta's avatar
rmagueta committed
1084 1085
    LOG_D(NR_MAC,
          "[RAPROC] DCI params: rnti 0x%x, rnti_type %d, dci_format %d coreset params: FreqDomainResource %llx, start_symbol %d  n_symb %d\n",
1086
          pdcch_pdu_rel15->dci_pdu[0].RNTI,
rmagueta's avatar
rmagueta committed
1087 1088
          NR_RNTI_RA,
          NR_DL_DCI_FORMAT_1_0,
1089 1090 1091
          (unsigned long long)pdcch_pdu_rel15->FreqDomainResource,
          pdcch_pdu_rel15->StartSymbolIndex,
          pdcch_pdu_rel15->DurationSymbols);
cig's avatar
cig committed
1092

1093
    fill_dci_pdu_rel15(scc,
1094
                       ra->CellGroup,
rmagueta's avatar
rmagueta committed
1095
                       &pdcch_pdu_rel15->dci_pdu[pdcch_pdu_rel15->numDlDci - 1],
1096
                       &dci_payload,
rmagueta's avatar
rmagueta committed
1097 1098 1099
                       NR_DL_DCI_FORMAT_1_0,
                       NR_RNTI_RA,
                       pdsch_pdu_rel15->BWPSize,
1100
                       bwpid);
cig's avatar
cig committed
1101 1102

    // DL TX request
1103
    nfapi_nr_pdu_t *tx_req = &nr_mac->TX_req[CC_id].pdu_list[nr_mac->TX_req[CC_id].Number_of_PDUs];
rmagueta's avatar
rmagueta committed
1104 1105

    // Program UL processing for Msg3
1106 1107 1108
    NR_BWP_Uplink_t *ubwp = ra->CellGroup ? 
      ra->CellGroup->spCellConfig->spCellConfigDedicated->uplinkConfig->uplinkBWP_ToAddModList->list.array[ra->bwp_id-1] : 
      NULL;
1109
    nr_get_Msg3alloc(module_idP, CC_id, scc, ubwp, slotP, frameP, ra, nr_mac->tdd_beam_association);
rmagueta's avatar
rmagueta committed
1110 1111
    nr_add_msg3(module_idP, CC_id, frameP, slotP, ra, (uint8_t *) &tx_req->TLVs[0].value.direct[0]);

1112
    if(ra->cfra) {
1113
      LOG_I(NR_MAC, "Frame %d, Subframe %d: Setting RA-Msg3 reception for Frame %d Subframe %d\n", frameP, slotP, ra->Msg3_frame, ra->Msg3_slot);
1114
    }
rmagueta's avatar
rmagueta committed
1115 1116 1117 1118

    T(T_GNB_MAC_DL_RAR_PDU_WITH_DATA, T_INT(module_idP), T_INT(CC_id), T_INT(ra->RA_rnti), T_INT(frameP),
      T_INT(slotP), T_INT(0), T_BUFFER(&tx_req->TLVs[0].value.direct[0], tx_req->TLVs[0].length));

cig's avatar
cig committed
1119
    tx_req->PDU_length = pdsch_pdu_rel15->TBSize[0];
1120
    tx_req->PDU_index = pduindex;
cig's avatar
cig committed
1121
    tx_req->num_TLV = 1;
1122
    tx_req->TLVs[0].length = tx_req->PDU_length + 2;
cig's avatar
cig committed
1123 1124 1125
    nr_mac->TX_req[CC_id].SFN = frameP;
    nr_mac->TX_req[CC_id].Number_of_PDUs++;
    nr_mac->TX_req[CC_id].Slot = slotP;
1126 1127 1128 1129

    // Mark the corresponding RBs as used
    for (int rb = 0; rb < rbSize; rb++) {
      vrb_map[rb + rbStart] = 1;
rmagueta's avatar
rmagueta committed
1130
    }
rmagueta's avatar
rmagueta committed
1131 1132

    ra->state = WAIT_Msg3;
1133
    LOG_I(NR_MAC,"[gNB %d][RAPROC] Frame %d, Subframe %d: RA state %d\n", module_idP, frameP, slotP, ra->state);
cig's avatar
cig committed
1134
  }
1135 1136
}

1137
void nr_generate_Msg4(module_id_t module_idP, int CC_id, frame_t frameP, sub_frame_t slotP, NR_RA_t *ra) {
1138 1139 1140

  gNB_MAC_INST *nr_mac = RC.nrmac[module_idP];
  NR_COMMON_channels_t *cc = &nr_mac->common_channels[CC_id];
1141
  NR_ServingCellConfigCommon_t *scc = cc->ServingCellConfigCommon;
1142 1143 1144

  if (ra->Msg4_frame == frameP && ra->Msg4_slot == slotP ) {

rmagueta's avatar
rmagueta committed
1145 1146
    uint8_t time_domain_assignment = 0;
    uint8_t mcsIndex = 0;
1147

1148 1149 1150
    NR_ServingCellConfigCommon_t *scc = cc->ServingCellConfigCommon;
    NR_SearchSpace_t *ss = ra->ra_ss;

1151 1152 1153 1154
    NR_BWP_Downlink_t *bwp =  ra->CellGroup ? ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.array[ra->bwp_id - 1] : NULL;
    NR_ControlResourceSet_t *coreset = get_coreset(scc,ra->CellGroup ? ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.array[ra->bwp_id - 1] : NULL, ss, NR_SearchSpace__searchSpaceType_PR_common);

    if (coreset == NULL) coreset = nr_mac->sched_ctrlCommon->coreset;
1155 1156 1157 1158

    int UE_id = find_nr_UE_id(module_idP, ra->rnti);
    NR_UE_info_t *UE_info = &nr_mac->UE_info;
    NR_UE_sched_ctrl_t *sched_ctrl = &UE_info->UE_sched_ctrl[UE_id];
1159

1160 1161 1162
    NR_BWP_t *genericParameters = bwp ? & bwp->bwp_Common->genericParameters : &scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters; 
    long BWPSize  = NRRIV2BW(genericParameters->locationAndBandwidth, MAX_BWP_SIZE);
    long BWPStart = NRRIV2PRBOFFSET(genericParameters->locationAndBandwidth, MAX_BWP_SIZE);
1163

1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
    // HARQ management
    int8_t current_harq_pid = sched_ctrl->dl_harq_pid;
    if (current_harq_pid < 0) {
      current_harq_pid = sched_ctrl->available_dl_harq.head;
      remove_front_nr_list(&sched_ctrl->available_dl_harq);
      sched_ctrl->dl_harq_pid = current_harq_pid;
    } else {
      if (sched_ctrl->harq_processes[current_harq_pid].round == 0)
        remove_nr_list(&sched_ctrl->available_dl_harq, current_harq_pid);
      else
        remove_nr_list(&sched_ctrl->retrans_dl_harq, current_harq_pid);
    }
    NR_UE_harq_t *harq = &sched_ctrl->harq_processes[current_harq_pid];
    DevAssert(!harq->is_waiting);
    add_tail_nr_list(&sched_ctrl->feedback_dl_harq, current_harq_pid);
    harq->is_waiting = true;
    ra->harq_pid = current_harq_pid;

1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
    // get CCEindex, needed also for PUCCH and then later for PDCCH
    uint8_t aggregation_level;
    uint8_t nr_of_candidates;
    find_aggregation_candidates(&aggregation_level, &nr_of_candidates, ss);
    int CCEIndex = allocate_nr_CCEs(nr_mac, bwp, coreset, aggregation_level,0,0,nr_of_candidates);
    if (CCEIndex < 0) {
      LOG_E(NR_MAC, "%s(): cannot find free CCE for RA RNTI %04x!\n", __func__, ra->rnti);
      return;
    }

    int n_rb=0;
    for (int i=0;i<6;i++)
      for (int j=0;j<8;j++) {
	n_rb+=((coreset->frequencyDomainResources.buf[i]>>j)&1);
      }
    n_rb*=6;
    const uint16_t N_cce = n_rb * coreset->duration / NR_NB_REG_PER_CCE;
1199
    const int delta_PRI=0;
1200 1201 1202
    int r_pucch = ((CCEIndex<<1)/N_cce)+(delta_PRI<<1);

    nr_acknack_scheduling(module_idP, UE_id, frameP, slotP,r_pucch);
1203 1204
    harq->feedback_slot = sched_ctrl->sched_pucch->ul_slot;

rmagueta's avatar
rmagueta committed
1205
    // Bytes to be transmitted
1206 1207
    uint8_t *buf = (uint8_t *) harq->tb;
    uint16_t mac_pdu_length = nr_write_ce_dlsch_pdu(module_idP, nr_mac->sched_ctrlCommon, buf, 255, ra->cont_res_id);
rmagueta's avatar
rmagueta committed
1208
    LOG_D(NR_MAC,"Encoded contention resolution mac_pdu_length %d\n",mac_pdu_length);
1209 1210 1211 1212
    uint16_t mac_sdu_length = mac_rrc_nr_data_req(module_idP, CC_id, frameP, CCCH, ra->rnti, 1, &buf[mac_pdu_length+2]);
    ((NR_MAC_SUBHEADER_SHORT *) &buf[mac_pdu_length])->R = 0;
    ((NR_MAC_SUBHEADER_SHORT *) &buf[mac_pdu_length])->F = 0;
    ((NR_MAC_SUBHEADER_SHORT *) &buf[mac_pdu_length])->LCID = DL_SCH_LCID_CCCH;
rmagueta's avatar
rmagueta committed
1213 1214 1215
    ((NR_MAC_SUBHEADER_SHORT *) &buf[mac_pdu_length])->L = mac_sdu_length;
    mac_pdu_length = mac_pdu_length + mac_sdu_length + sizeof(NR_MAC_SUBHEADER_SHORT);

1216 1217 1218 1219
    LOG_D(NR_MAC,"Encoded RRCSetup Piggyback (%d + %d bytes), mac_pdu_length %d\n",
	  mac_sdu_length,
	  (int)sizeof(NR_MAC_SUBHEADER_SHORT),
	  mac_pdu_length);
rmagueta's avatar
rmagueta committed
1220 1221
    // Calculate number of symbols
    int startSymbolIndex, nrOfSymbols;
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233

    NR_PDSCH_TimeDomainResourceAllocationList_t *pdsch_TimeDomainAllocationList;
    if (bwp &&
	bwp->bwp_Common &&
	bwp->bwp_Common->pdsch_ConfigCommon &&
	bwp->bwp_Common->pdsch_ConfigCommon->choice.setup &&
	bwp->bwp_Common->pdsch_ConfigCommon->choice.setup->pdsch_TimeDomainAllocationList) 
      pdsch_TimeDomainAllocationList = bwp->bwp_Common->pdsch_ConfigCommon->choice.setup->pdsch_TimeDomainAllocationList;
    else 
      pdsch_TimeDomainAllocationList = scc->downlinkConfigCommon->initialDownlinkBWP->pdsch_ConfigCommon->choice.setup->pdsch_TimeDomainAllocationList;
        
    const int startSymbolAndLength = pdsch_TimeDomainAllocationList->list.array[time_domain_assignment]->startSymbolAndLength;
rmagueta's avatar
rmagueta committed
1234 1235
    SLIV2SL(startSymbolAndLength, &startSymbolIndex, &nrOfSymbols);
    AssertFatal(startSymbolIndex >= 0, "StartSymbolIndex is negative\n");
1236

1237
    uint16_t dlDmrsSymbPos = fill_dmrs_mask(NULL,
1238
                                            scc->dmrs_TypeA_Position,
rmagueta's avatar
rmagueta committed
1239 1240
                                            nrOfSymbols,
                                            startSymbolIndex);
1241

rmagueta's avatar
rmagueta committed
1242
    uint16_t N_DMRS_SLOT = get_num_dmrs(dlDmrsSymbPos);
rmagueta's avatar
rmagueta committed
1243

1244
    long dmrsConfigType = bwp ? (bwp->bwp_Dedicated->pdsch_Config->choice.setup->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_Type == NULL ? 0 : 1):0;
rmagueta's avatar
rmagueta committed
1245
    uint8_t N_PRB_DMRS = 0;
1246 1247 1248 1249
    AssertFatal(nr_mac->sched_ctrlCommon->numDmrsCdmGrpsNoData == 1 || 
		nr_mac->sched_ctrlCommon->numDmrsCdmGrpsNoData == 2,
		"nr_mac->schedCtrlCommon->numDmrsCdmGrpsNoData %d is not possible",
		nr_mac->sched_ctrlCommon->numDmrsCdmGrpsNoData);
rmagueta's avatar
rmagueta committed
1250 1251 1252 1253 1254 1255 1256
    if (dmrsConfigType==NFAPI_NR_DMRS_TYPE1) {
      N_PRB_DMRS = nr_mac->sched_ctrlCommon->numDmrsCdmGrpsNoData * 6;
    }
    else {
      N_PRB_DMRS = nr_mac->sched_ctrlCommon->numDmrsCdmGrpsNoData * 4;
    }

rmagueta's avatar
rmagueta committed
1257
    uint8_t mcsTableIdx = 0;
1258 1259 1260 1261 1262
    if (bwp &&
	bwp->bwp_Dedicated &&
	bwp->bwp_Dedicated->pdsch_Config &&
	bwp->bwp_Dedicated->pdsch_Config->choice.setup &&
	bwp->bwp_Dedicated->pdsch_Config->choice.setup->mcs_Table) {
1263
      if (*bwp->bwp_Dedicated->pdsch_Config->choice.setup->mcs_Table == 0)
rmagueta's avatar
rmagueta committed
1264
        mcsTableIdx = 1;
1265
      else
rmagueta's avatar
rmagueta committed
1266
        mcsTableIdx = 2;
1267
    }
1268
    else mcsTableIdx = 0;
rmagueta's avatar
rmagueta committed
1269

rmagueta's avatar
rmagueta committed
1270 1271 1272 1273
    int rbStart = 0;
    int rbSize = 0;
    uint8_t tb_scaling = 0;
    uint16_t *vrb_map = cc[CC_id].vrb_map;
rmagueta's avatar
rmagueta committed
1274 1275
    do {
      rbSize++;
rmagueta's avatar
rmagueta committed
1276
      LOG_D(NR_MAC,"Calling nr_compute_tbs with N_PRB_DMRS %d, N_DMRS_SLOT %d\n",N_PRB_DMRS,N_DMRS_SLOT);
1277
      harq->tb_size = nr_compute_tbs(nr_get_Qm_dl(mcsIndex, mcsTableIdx),
rmagueta's avatar
rmagueta committed
1278 1279
                           nr_get_code_rate_dl(mcsIndex, mcsTableIdx),
                           rbSize, nrOfSymbols, N_PRB_DMRS * N_DMRS_SLOT, 0, tb_scaling,1) >> 3;
1280
    } while (rbStart + rbSize < BWPSize && !vrb_map[rbStart + rbSize] && harq->tb_size < mac_pdu_length);
rmagueta's avatar
rmagueta committed
1281 1282 1283 1284 1285 1286 1287 1288 1289

    for (int i = 0; (i < rbSize) && (rbStart <= (BWPSize - rbSize)); i++) {
      if (vrb_map[rbStart + i]) {
        rbStart += i;
        i = 0;
      }
    }

    if (rbStart > (BWPSize - rbSize)) {
rmagueta's avatar
rmagueta committed
1290
      LOG_E(NR_MAC, "%s(): cannot find free vrb_map for RNTI %04x!\n", __func__, ra->rnti);
rmagueta's avatar
rmagueta committed
1291 1292
      return;
    }
rmagueta's avatar
rmagueta committed
1293

1294
    // Checking if the DCI allocation is feasible in current subframe
rmagueta's avatar
rmagueta committed
1295
    nfapi_nr_dl_tti_request_body_t *dl_req = &nr_mac->DL_req[CC_id].dl_tti_request_body;
1296 1297 1298 1299 1300 1301 1302 1303
    if (dl_req->nPDUs > NFAPI_NR_MAX_DL_TTI_PDUS - 2) {
      LOG_I(NR_MAC, "[RAPROC] Subframe %d: FAPI DL structure is full, skip scheduling UE %d\n", slotP, ra->rnti);
      return;
    }


    // look up the PDCCH PDU for this CC, BWP, and CORESET. If it does not exist, create it. This is especially
    // important if we have multiple RAs, and the DLSCH has to reuse them, so we need to mark them
1304
    const int bwpid = bwp ? bwp->bwp_Id : 0;
1305
    const int coresetid = coreset->controlResourceSetId;
1306
    nfapi_nr_dl_tti_pdcch_pdu_rel15_t *pdcch_pdu_rel15 = nr_mac->pdcch_pdu_idx[CC_id][ra->bwp_id][coresetid];
1307 1308 1309 1310 1311 1312 1313 1314
    if (!pdcch_pdu_rel15) {
      nfapi_nr_dl_tti_request_pdu_t *dl_tti_pdcch_pdu = &dl_req->dl_tti_pdu_list[dl_req->nPDUs];
      memset(dl_tti_pdcch_pdu, 0, sizeof(nfapi_nr_dl_tti_request_pdu_t));
      dl_tti_pdcch_pdu->PDUType = NFAPI_NR_DL_TTI_PDCCH_PDU_TYPE;
      dl_tti_pdcch_pdu->PDUSize = (uint8_t)(2 + sizeof(nfapi_nr_dl_tti_pdcch_pdu));
      dl_req->nPDUs += 1;
      pdcch_pdu_rel15 = &dl_tti_pdcch_pdu->pdcch_pdu.pdcch_pdu_rel15;
      nr_configure_pdcch(pdcch_pdu_rel15, ss, coreset, scc, bwp);
1315
      nr_mac->pdcch_pdu_idx[CC_id][ra->bwp_id][coresetid] = pdcch_pdu_rel15;
1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
    }

    nfapi_nr_dl_tti_request_pdu_t *dl_tti_pdsch_pdu = &dl_req->dl_tti_pdu_list[dl_req->nPDUs];
    memset((void *)dl_tti_pdsch_pdu,0,sizeof(nfapi_nr_dl_tti_request_pdu_t));
    dl_tti_pdsch_pdu->PDUType = NFAPI_NR_DL_TTI_PDSCH_PDU_TYPE;
    dl_tti_pdsch_pdu->PDUSize = (uint8_t)(2+sizeof(nfapi_nr_dl_tti_pdsch_pdu));
    dl_req->nPDUs+=1;
    nfapi_nr_dl_tti_pdsch_pdu_rel15_t *pdsch_pdu_rel15 = &dl_tti_pdsch_pdu->pdsch_pdu.pdsch_pdu_rel15;

    LOG_I(NR_MAC,"[gNB %d] [RAPROC] CC_id %d Frame %d, slotP %d: Generating RA-Msg4 DCI, state %d\n", module_idP, CC_id, frameP, slotP, ra->state);

1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
    int bwp_Id=0;
    if (ra->CellGroup && 
	ra->CellGroup->spCellConfig && 
	ra->CellGroup->spCellConfig->spCellConfigDedicated && 
	ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList){ 
      bwp_Id = *ra->CellGroup->spCellConfig->spCellConfigDedicated->firstActiveDownlinkBWP_Id; 
      AssertFatal(ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count <= 1,
		  "downlinkBWP_ToAddModList has %d BWP!\n",
		  ra->CellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count);
    }
    LOG_I(NR_MAC,"[gNB %d] [RAPROC] CC_id %d Frame %d, slotP %d: Generating RA-Msg4 DCI for BWP %d, state %d\n", module_idP, CC_id, frameP, slotP, bwp_Id,ra->state);
1338 1339 1340 1341

    // SCF222: PDU index incremented for each PDSCH PDU sent in TX control message. This is used to associate control
    // information to data and is reset every slot.
    const int pduindex = nr_mac->pdu_index[CC_id]++;
rmagueta's avatar
rmagueta committed
1342 1343 1344

    pdsch_pdu_rel15->pduBitmap = 0;
    pdsch_pdu_rel15->rnti = ra->rnti;
1345
    pdsch_pdu_rel15->pduIndex = pduindex;
rmagueta's avatar
rmagueta committed
1346 1347
    pdsch_pdu_rel15->BWPSize  = BWPSize;
    pdsch_pdu_rel15->BWPStart = BWPStart;
1348
    pdsch_pdu_rel15->SubcarrierSpacing = genericParameters->subcarrierSpacing;
1349 1350
    pdsch_pdu_rel15->CyclicPrefix = 0;
    pdsch_pdu_rel15->NrOfCodewords = 1;
rmagueta's avatar
rmagueta committed
1351
    pdsch_pdu_rel15->targetCodeRate[0] = nr_get_code_rate_dl(mcsIndex,mcsTableIdx);
1352 1353
    pdsch_pdu_rel15->qamModOrder[0] = 2;
    pdsch_pdu_rel15->mcsIndex[0] = mcsIndex;
rmagueta's avatar
rmagueta committed
1354
    pdsch_pdu_rel15->mcsTable[0] = mcsTableIdx;
1355
    pdsch_pdu_rel15->rvIndex[0] = nr_rv_round_map[harq->round];
cig's avatar
cig committed
1356 1357 1358 1359
    pdsch_pdu_rel15->dataScramblingId = *scc->physCellId;
    pdsch_pdu_rel15->nrOfLayers = 1;
    pdsch_pdu_rel15->transmissionScheme = 0;
    pdsch_pdu_rel15->refPoint = 0;
rmagueta's avatar
rmagueta committed
1360
    pdsch_pdu_rel15->dmrsConfigType = dmrsConfigType;
cig's avatar
cig committed
1361 1362
    pdsch_pdu_rel15->dlDmrsScramblingId = *scc->physCellId;
    pdsch_pdu_rel15->SCID = 0;
1363
    pdsch_pdu_rel15->numDmrsCdmGrpsNoData = nrOfSymbols <=2 ? 1 : 2;
cig's avatar
cig committed
1364 1365
    pdsch_pdu_rel15->dmrsPorts = 1;
    pdsch_pdu_rel15->resourceAlloc = 1;
1366 1367
    pdsch_pdu_rel15->rbStart = rbStart;
    pdsch_pdu_rel15->rbSize = rbSize;
1368
    pdsch_pdu_rel15->VRBtoPRBMapping = 0;
rmagueta's avatar
rmagueta committed
1369 1370 1371
    pdsch_pdu_rel15->StartSymbolIndex = startSymbolIndex;
    pdsch_pdu_rel15->NrOfSymbols = nrOfSymbols;
    pdsch_pdu_rel15->dlDmrsSymbPos = dlDmrsSymbPos;
cig's avatar
cig committed
1372

1373

rmagueta's avatar
rmagueta committed
1374 1375
    int x_Overhead = 0;
    nr_get_tbs_dl(&dl_tti_pdsch_pdu->pdsch_pdu, x_Overhead, pdsch_pdu_rel15->numDmrsCdmGrpsNoData, tb_scaling);
cig's avatar
cig committed
1376

1377 1378 1379 1380 1381 1382
    pdsch_pdu_rel15->precodingAndBeamforming.num_prgs=1;
    pdsch_pdu_rel15->precodingAndBeamforming.prg_size=275;
    pdsch_pdu_rel15->precodingAndBeamforming.dig_bf_interfaces=1;
    pdsch_pdu_rel15->precodingAndBeamforming.prgs_list[0].pm_idx = 0;
    pdsch_pdu_rel15->precodingAndBeamforming.prgs_list[0].dig_bf_interface_list[0].beam_idx = ra->beam_id;

1383 1384 1385
    /* Fill PDCCH DL DCI PDU */
    nfapi_nr_dl_dci_pdu_t *dci_pdu = &pdcch_pdu_rel15->dci_pdu[pdcch_pdu_rel15->numDlDci];
    pdcch_pdu_rel15->numDlDci++;
1386
    dci_pdu->RNTI = ra->rnti;
1387 1388 1389 1390 1391 1392 1393 1394 1395
    dci_pdu->ScramblingId = *scc->physCellId;
    dci_pdu->ScramblingRNTI = 0;
    dci_pdu->AggregationLevel = aggregation_level;
    dci_pdu->CceIndex = CCEIndex;
    dci_pdu->beta_PDCCH_1_0 = 0;
    dci_pdu->powerControlOffsetSS = 1;

    dci_pdu_rel15_t dci_payload;
    dci_payload.frequency_domain_assignment.val = PRBalloc_to_locationandbandwidth0(pdsch_pdu_rel15->rbSize,
1396
                                                                                    pdsch_pdu_rel15->rbStart,
rmagueta's avatar
rmagueta committed
1397 1398
                                                                                    pdsch_pdu_rel15->BWPSize);

1399
    dci_payload.format_indicator = 1;
1400 1401 1402
    dci_payload.time_domain_assignment.val = time_domain_assignment;
    dci_payload.vrb_to_prb_mapping.val = 0;
    dci_payload.mcs = pdsch_pdu_rel15->mcsIndex[0];
rmagueta's avatar
rmagueta committed
1403
    dci_payload.tb_scaling = tb_scaling;
1404 1405 1406 1407 1408
    dci_payload.rv = pdsch_pdu_rel15->rvIndex[0];
    dci_payload.harq_pid = current_harq_pid;
    dci_payload.ndi = harq->ndi;
    dci_payload.dai[0].val = (sched_ctrl->sched_pucch->dai_c-1)&3;
    dci_payload.tpc = sched_ctrl->tpc1; // TPC for PUCCH: table 7.2.1-1 in 38.213
1409
    dci_payload.pucch_resource_indicator = delta_PRI; // This is delta_PRI from 9.2.1 in 38.213
1410
    dci_payload.pdsch_to_harq_feedback_timing_indicator.val = sched_ctrl->sched_pucch->timing_indicator;
1411

rmagueta's avatar
rmagueta committed
1412
    LOG_D(NR_MAC,
1413
          "[RAPROC] DCI type 1 payload: freq_alloc %d (%d,%d,%d), time_alloc %d, vrb to prb %d, mcs %d tb_scaling %d pucchres %d harqtiming %d\n",
1414
          dci_payload.frequency_domain_assignment.val,
1415 1416
          pdsch_pdu_rel15->rbStart,
          pdsch_pdu_rel15->rbSize,
rmagueta's avatar
rmagueta committed
1417
          pdsch_pdu_rel15->BWPSize,
1418 1419 1420
          dci_payload.time_domain_assignment.val,
          dci_payload.vrb_to_prb_mapping.val,
          dci_payload.mcs,
1421 1422 1423
          dci_payload.tb_scaling,
	  dci_payload.pucch_resource_indicator,
	  dci_payload.pdsch_to_harq_feedback_timing_indicator.val);
cig's avatar
cig committed
1424

rmagueta's avatar
rmagueta committed
1425
    LOG_D(NR_MAC,
1426
          "[RAPROC] DCI params: rnti 0x%x, rnti_type %d, dci_format %d coreset params: FreqDomainResource %llx, start_symbol %d  n_symb %d\n",
1427
          pdcch_pdu_rel15->dci_pdu[0].RNTI,
rmagueta's avatar
rmagueta committed
1428 1429
          NR_RNTI_TC,
          NR_DL_DCI_FORMAT_1_0,
1430 1431 1432
          (unsigned long long)pdcch_pdu_rel15->FreqDomainResource,
          pdcch_pdu_rel15->StartSymbolIndex,
          pdcch_pdu_rel15->DurationSymbols);
cig's avatar
cig committed
1433

1434
    fill_dci_pdu_rel15(scc,
1435
                       ra->CellGroup,
rmagueta's avatar
rmagueta committed
1436
                       &pdcch_pdu_rel15->dci_pdu[pdcch_pdu_rel15->numDlDci - 1],
1437
                       &dci_payload,
rmagueta's avatar
rmagueta committed
1438 1439 1440
                       NR_DL_DCI_FORMAT_1_0,
                       NR_RNTI_TC,
                       pdsch_pdu_rel15->BWPSize,
1441
                       bwp_Id);
1442

1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
    // Add padding header and zero rest out if there is space left
    if (mac_pdu_length < harq->tb_size) {
      NR_MAC_SUBHEADER_FIXED *padding = (NR_MAC_SUBHEADER_FIXED *) &buf[mac_pdu_length];
      padding->R = 0;
      padding->LCID = DL_SCH_LCID_PADDING;
      for(int k = mac_pdu_length+1; k<harq->tb_size; k++) {
        buf[k] = 0;
      }
    }

cig's avatar
cig committed
1453
    // DL TX request
1454
    nfapi_nr_pdu_t *tx_req = &nr_mac->TX_req[CC_id].pdu_list[nr_mac->TX_req[CC_id].Number_of_PDUs];
1455 1456
    memcpy(tx_req->TLVs[0].value.direct, harq->tb, sizeof(uint8_t) * harq->tb_size);
    tx_req->PDU_length =  harq->tb_size;
1457
    tx_req->PDU_index = pduindex;
cig's avatar
cig committed
1458
    tx_req->num_TLV = 1;
1459
    tx_req->TLVs[0].length =  harq->tb_size + 2;
cig's avatar
cig committed
1460 1461 1462
    nr_mac->TX_req[CC_id].SFN = frameP;
    nr_mac->TX_req[CC_id].Number_of_PDUs++;
    nr_mac->TX_req[CC_id].Slot = slotP;
1463

1464
    // Mark the corresponding RBs as used
1465 1466 1467 1468
    for (int rb = 0; rb < pdsch_pdu_rel15->rbSize; rb++) {
      vrb_map[rb + pdsch_pdu_rel15->rbStart] = 1;
    }

rmagueta's avatar
rmagueta committed
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
    LOG_D(NR_MAC,"BWPSize: %i\n", pdcch_pdu_rel15->BWPSize);
    LOG_D(NR_MAC,"BWPStart: %i\n", pdcch_pdu_rel15->BWPStart);
    LOG_D(NR_MAC,"SubcarrierSpacing: %i\n", pdcch_pdu_rel15->SubcarrierSpacing);
    LOG_D(NR_MAC,"CyclicPrefix: %i\n", pdcch_pdu_rel15->CyclicPrefix);
    LOG_D(NR_MAC,"StartSymbolIndex: %i\n", pdcch_pdu_rel15->StartSymbolIndex);
    LOG_D(NR_MAC,"DurationSymbols: %i\n", pdcch_pdu_rel15->DurationSymbols);
    for(int n=0;n<6;n++) LOG_D(NR_MAC,"FreqDomainResource[%i]: %x\n",n, pdcch_pdu_rel15->FreqDomainResource[n]);
    LOG_D(NR_MAC,"CceRegMappingType: %i\n", pdcch_pdu_rel15->CceRegMappingType);
    LOG_D(NR_MAC,"RegBundleSize: %i\n", pdcch_pdu_rel15->RegBundleSize);
    LOG_D(NR_MAC,"InterleaverSize: %i\n", pdcch_pdu_rel15->InterleaverSize);
    LOG_D(NR_MAC,"CoreSetType: %i\n", pdcch_pdu_rel15->CoreSetType);
    LOG_D(NR_MAC,"ShiftIndex: %i\n", pdcch_pdu_rel15->ShiftIndex);
    LOG_D(NR_MAC,"precoderGranularity: %i\n", pdcch_pdu_rel15->precoderGranularity);
    LOG_D(NR_MAC,"numDlDci: %i\n", pdcch_pdu_rel15->numDlDci);

    ra->state = WAIT_Msg4_ACK;
1485
    LOG_I(NR_MAC,"[gNB %d][RAPROC] Frame %d, Subframe %d: RA state %d\n", module_idP, frameP, slotP, ra->state);
1486 1487
  }
}
1488

1489
void nr_check_Msg4_Ack(module_id_t module_id, int CC_id, frame_t frame, sub_frame_t slot, NR_RA_t *ra) {
1490

1491 1492
  int UE_id = find_nr_UE_id(module_id, ra->rnti);
  const int current_harq_pid = ra->harq_pid;
1493

1494 1495 1496
  NR_UE_info_t *UE_info = &RC.nrmac[module_id]->UE_info;
  NR_UE_harq_t *harq = &UE_info->UE_sched_ctrl[UE_id].harq_processes[current_harq_pid];

1497
  LOG_D(NR_MAC, "ue %d, rnti %d, harq is waiting %d, round %d, frame %d %d, harq id %d\n", UE_id, ra->rnti, harq->is_waiting, harq->round, frame, slot, current_harq_pid);
1498 1499 1500 1501 1502

  if (harq->is_waiting == 0)
  {
    if (harq->round == 0)
    {
1503
      LOG_I(NR_MAC, "(ue %i, rnti 0x%04x) Received Ack of RA-Msg4. CBRA procedure succeeded!\n", UE_id, ra->rnti);
1504
      nr_clear_ra_proc(module_id, CC_id, frame, ra);
1505
      UE_info->active[UE_id] = true;
1506
      UE_info->Msg4_ACKed[UE_id] = true;
1507 1508 1509 1510 1511
    }
    else
    {
      ra->state = Msg4;
    }
cig's avatar
cig committed
1512
  }
1513

1514 1515
}

1516
void nr_clear_ra_proc(module_id_t module_idP, int CC_id, frame_t frameP, NR_RA_t *ra){
1517
  LOG_D(NR_MAC,"[gNB %d][RAPROC] CC_id %d Frame %d Clear Random access information rnti %x\n", module_idP, CC_id, frameP, ra->rnti);
1518
  ra->state = RA_IDLE;
cig's avatar
cig committed
1519 1520 1521 1522
  ra->timing_offset = 0;
  ra->RRC_timer = 20;
  ra->rnti = 0;
  ra->msg3_round = 0;
1523 1524
}

1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549

/////////////////////////////////////
//    Random Access Response PDU   //
//         TS 38.213 ch 8.2        //
//        TS 38.321 ch 6.2.3       //
/////////////////////////////////////
//| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |// bit-wise
//| E | T |       R A P I D       |//
//| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |//
//| R |           T A             |//
//|       T A         |  UL grant |//
//|            UL grant           |//
//|            UL grant           |//
//|            UL grant           |//
//|         T C - R N T I         |//
//|         T C - R N T I         |//
/////////////////////////////////////
//       UL grant  (27 bits)       //
/////////////////////////////////////
//| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |// bit-wise
//|-------------------|FHF|F_alloc|//
//|        Freq allocation        |//
//|    F_alloc    |Time allocation|//
//|      MCS      |     TPC   |CSI|//
/////////////////////////////////////
cig's avatar
cig committed
1550
// WIP
cig's avatar
cig committed
1551 1552 1553
// todo:
// - handle MAC RAR BI subheader
// - sending only 1 RAR subPDU
1554
// - UL Grant: hardcoded CSI, TPC, time alloc
cig's avatar
cig committed
1555
// - padding
1556 1557
void nr_fill_rar(uint8_t Mod_idP,
                 NR_RA_t * ra,
cig's avatar
cig committed
1558
                 uint8_t * dlsch_buffer,
1559
                 nfapi_nr_pusch_pdu_t  *pusch_pdu){
cig's avatar
cig committed
1560

1561
  LOG_I(NR_MAC, "[gNB] Generate RAR MAC PDU frame %d slot %d preamble index %u TA command %d \n", ra->Msg2_frame, ra-> Msg2_slot, ra->preamble_index, ra->timing_offset);
1562 1563 1564
  NR_RA_HEADER_BI *rarbi = (NR_RA_HEADER_BI *) dlsch_buffer;
  NR_RA_HEADER_RAPID *rarh = (NR_RA_HEADER_RAPID *) (dlsch_buffer + 1);
  NR_MAC_RAR *rar = (NR_MAC_RAR *) (dlsch_buffer + 2);
Francesco Mani's avatar
Francesco Mani committed
1565
  unsigned char csi_req = 0, tpc_command;
1566 1567
  //uint8_t N_UL_Hop;
  uint8_t valid_bits;
1568 1569
  uint32_t ul_grant;
  uint16_t f_alloc, prb_alloc, bwp_size, truncation=0;
1570

Francesco Mani's avatar
Francesco Mani committed
1571 1572
  tpc_command = 3; // this is 0 dB

1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
  /// E/T/R/R/BI subheader ///
  // E = 1, MAC PDU includes another MAC sub-PDU (RAPID)
  // T = 0, Back-off indicator subheader
  // R = 2, Reserved
  // BI = 0, 5ms
  rarbi->E = 1;
  rarbi->T = 0;
  rarbi->R = 0;
  rarbi->BI = 0;

1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
  /// E/T/RAPID subheader ///
  // E = 0, one only RAR, first and last
  // T = 1, RAPID
  rarh->E = 0;
  rarh->T = 1;
  rarh->RAPID = ra->preamble_index;

  /// RAR MAC payload ///
  rar->R = 0;

  // TA command
  rar->TA1 = (uint8_t) (ra->timing_offset >> 5);    // 7 MSBs of timing advance
  rar->TA2 = (uint8_t) (ra->timing_offset & 0x1f);  // 5 LSBs of timing advance

  // TC-RNTI
  rar->TCRNTI_1 = (uint8_t) (ra->rnti >> 8);        // 8 MSBs of rnti
  rar->TCRNTI_2 = (uint8_t) (ra->rnti & 0xff);      // 8 LSBs of rnti

  // UL grant
1602

1603
  ra->msg3_TPC = tpc_command;
1604

1605
  bwp_size = pusch_pdu->bwp_size;
1606
  prb_alloc = PRBalloc_to_locationandbandwidth0(ra->msg3_nb_rb, ra->msg3_first_rb, bwp_size);
1607 1608 1609 1610 1611 1612
  if (bwp_size>180) {
    AssertFatal(1==0,"Initial UBWP larger than 180 currently not supported");
  }
  else {
    valid_bits = (uint8_t)ceil(log2(bwp_size*(bwp_size+1)>>1));
  }
1613

1614 1615
  if (pusch_pdu->frequency_hopping){
    AssertFatal(1==0,"PUSCH with frequency hopping currently not supported");
1616
  } else {
1617 1618 1619
    for (int i=0; i<valid_bits; i++)
      truncation |= (1<<i);
    f_alloc = (prb_alloc&truncation);
1620
  }
1621

1622
  ul_grant = csi_req | (tpc_command << 1) | (pusch_pdu->mcs_index << 4) | (ra->Msg3_tda_id << 8) | (f_alloc << 12) | (pusch_pdu->frequency_hopping << 26);
1623

1624 1625 1626 1627
  rar->UL_GRANT_1 = (uint8_t) (ul_grant >> 24) & 0x07;
  rar->UL_GRANT_2 = (uint8_t) (ul_grant >> 16) & 0xff;
  rar->UL_GRANT_3 = (uint8_t) (ul_grant >> 8) & 0xff;
  rar->UL_GRANT_4 = (uint8_t) ul_grant & 0xff;
1628

rmagueta's avatar
rmagueta committed
1629
#ifdef DEBUG_RAR
1630 1631 1632 1633 1634
  //LOG_I(NR_MAC, "rarbi->E = 0x%x\n", rarbi->E);
  //LOG_I(NR_MAC, "rarbi->T = 0x%x\n", rarbi->T);
  //LOG_I(NR_MAC, "rarbi->R = 0x%x\n", rarbi->R);
  //LOG_I(NR_MAC, "rarbi->BI = 0x%x\n", rarbi->BI);

rmagueta's avatar
rmagueta committed
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
  LOG_I(NR_MAC, "rarh->E = 0x%x\n", rarh->E);
  LOG_I(NR_MAC, "rarh->T = 0x%x\n", rarh->T);
  LOG_I(NR_MAC, "rarh->RAPID = 0x%x (%i)\n", rarh->RAPID, rarh->RAPID);

  LOG_I(NR_MAC, "rar->R = 0x%x\n", rar->R);
  LOG_I(NR_MAC, "rar->TA1 = 0x%x\n", rar->TA1);

  LOG_I(NR_MAC, "rar->TA2 = 0x%x\n", rar->TA2);
  LOG_I(NR_MAC, "rar->UL_GRANT_1 = 0x%x\n", rar->UL_GRANT_1);

  LOG_I(NR_MAC, "rar->UL_GRANT_2 = 0x%x\n", rar->UL_GRANT_2);
  LOG_I(NR_MAC, "rar->UL_GRANT_3 = 0x%x\n", rar->UL_GRANT_3);
  LOG_I(NR_MAC, "rar->UL_GRANT_4 = 0x%x\n", rar->UL_GRANT_4);

  LOG_I(NR_MAC, "rar->TCRNTI_1 = 0x%x\n", rar->TCRNTI_1);
  LOG_I(NR_MAC, "rar->TCRNTI_2 = 0x%x\n", rar->TCRNTI_2);
rmagueta's avatar
rmagueta committed
1651
#endif
rmagueta's avatar
rmagueta committed
1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674

  int mcs = (unsigned char) (rar->UL_GRANT_4 >> 4);
  // time alloc
  int Msg3_t_alloc = (unsigned char) (rar->UL_GRANT_3 & 0x07);
  // frequency alloc
  int Msg3_f_alloc = (uint16_t) ((rar->UL_GRANT_3 >> 4) | (rar->UL_GRANT_2 << 4) | ((rar->UL_GRANT_1 & 0x03) << 12));
  // frequency hopping
  int freq_hopping = (unsigned char) (rar->UL_GRANT_1 >> 2);
  // TA command
  int  ta_command = rar->TA2 + (rar->TA1 << 5);
  // TC-RNTI
  int t_crnti = rar->TCRNTI_2 + (rar->TCRNTI_1 << 8);

  LOG_I(NR_MAC, "In %s: Transmitted RAR with t_alloc %d f_alloc %d ta_command %d mcs %d freq_hopping %d tpc_command %d csi_req %d t_crnti %x \n",
        __FUNCTION__,
        Msg3_t_alloc,
        Msg3_f_alloc,
        ta_command,
        mcs,
        freq_hopping,
        tpc_command,
        csi_req,
        t_crnti);
1675
}