fapi_5g/source/api/fapi2phy/p7/nr5g_fapi_proc_ul_tti_req.c

   1 /******************************************************************************
   2 *
   3 *   Copyright (c) 2021 Intel.
   4 *
   5 *   Licensed under the Apache License, Version 2.0 (the "License");
   6 *   you may not use this file except in compliance with the License.
   7 *   You may obtain a copy of the License at
   8 *
   9 *       http://www.apache.org/licenses/LICENSE-2.0
  10 *
  11 *   Unless required by applicable law or agreed to in writing, software
  12 *   distributed under the License is distributed on an "AS IS" BASIS,
  13 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 *   See the License for the specific language governing permissions and
  15 *   limitations under the License.
  16 *
  17 *******************************************************************************/
  18
  19 /**
  20  * @file
  21  * This file consist of implementation of FAPI UL_TTI.request message.
  22  *
  23  **/
  24
  25 #include "nr5g_fapi_framework.h"
  26 #include "nr5g_fapi_fapi2mac_api.h"
  27 #include "nr5g_fapi_fapi2phy_api.h"
  28 #include "nr5g_fapi_fapi2phy_p7_proc.h"
  29 #include "nr5g_fapi_fapi2phy_p7_pvt_proc.h"
  30 #include "nr5g_fapi_memory.h"
  31 #include <math.h>
  32
  33 #define NUM_UL_PTRS_PORT_INDEX (12)
  34
  35  /** @ingroup group_source_api_p7_fapi2phy_proc
  36  *
  37  *  @param[in]  p_phy_instance Pointer to PHY instance.
  38  *  @param[in]  p_fapi_req Pointer to FAPI UL_TTI.request message structure.
  39  *
  40  *  @return     Returns ::SUCCESS and ::FAILURE.
  41  *
  42  *  @description
  43  *  This message indicates the control information for an uplink slot.
  44  *
  45 **/
  46 uint8_t nr5g_fapi_ul_tti_request(
  47     bool is_urllc,
  48     p_nr5g_fapi_phy_instance_t p_phy_instance,
  49     fapi_ul_tti_req_t * p_fapi_req,
  50     fapi_vendor_msg_t * p_fapi_vendor_msg)
  51 {
  52     PULConfigRequestStruct p_ia_ul_config_req;
  53     PMAC2PHY_QUEUE_EL p_list_elem;
  54     nr5g_fapi_stats_t *p_stats;
  55
  56     if (NULL == p_phy_instance) {
  57         NR5G_FAPI_LOG(ERROR_LOG, ("[NR5G_FAPI][UL_TTI.request] Invalid "
  58                 "phy instance"));
  59         return FAILURE;
  60     }
  61     p_stats = &p_phy_instance->stats;
  62     p_stats->fapi_stats.fapi_ul_tti_req++;
  63
  64     if (NULL == p_fapi_req) {
  65         NR5G_FAPI_LOG(ERROR_LOG, ("[NR5G_FAPI][UL_TTI.request] Invalid fapi "
  66                 "message"));
  67         return FAILURE;
  68     }
  69
  70     p_list_elem = nr5g_fapi_fapi2phy_create_api_list_elem((uint8_t)
  71         MSG_TYPE_PHY_UL_CONFIG_REQ, 1,
  72         (uint32_t) sizeof(ULConfigRequestStruct));
  73     if (!p_list_elem) {
  74         NR5G_FAPI_LOG(ERROR_LOG,
  75             ("[NR5G_FAPI][UL_TTI.request] Unable to create "
  76                 "list element. Out of memory!!!"));
  77         return FAILURE;
  78     }
  79
  80     p_ia_ul_config_req = (PULConfigRequestStruct) (p_list_elem + 1);
  81     NR5G_FAPI_MEMSET(p_ia_ul_config_req, sizeof(ULConfigRequestStruct), 0,
  82         sizeof(ULConfigRequestStruct));
  83     p_ia_ul_config_req->sMsgHdr.nMessageType = MSG_TYPE_PHY_UL_CONFIG_REQ;
  84     p_ia_ul_config_req->sMsgHdr.nMessageLen =
  85         (uint16_t) sizeof(ULConfigRequestStruct);
  86
  87     if (FAILURE == nr5g_fapi_ul_tti_req_to_phy_translation(is_urllc, p_phy_instance,
  88             p_fapi_req, p_fapi_vendor_msg, p_ia_ul_config_req)) {
  89         nr5g_fapi_fapi2phy_destroy_api_list_elem(p_list_elem);
  90         NR5G_FAPI_LOG(DEBUG_LOG, ("[UL_TTI.request][%d][%d,%d] Not Sent",
  91                 p_phy_instance->phy_id, p_ia_ul_config_req->sSFN_Slot.nSFN,
  92                 p_ia_ul_config_req->sSFN_Slot.nSlot));
  93         return FAILURE;
  94     }
  95
  96     nr5g_fapi_fapi2phy_add_to_api_list(is_urllc, p_list_elem);
  97
  98     p_stats->iapi_stats.iapi_ul_config_req++;
  99     NR5G_FAPI_LOG(DEBUG_LOG, ("[UL_TTI.request][%u][%u,%u,%u] is_urllc %u",
 100             p_phy_instance->phy_id,
 101         p_ia_ul_config_req->sSFN_Slot.nSFN, p_ia_ul_config_req->sSFN_Slot.nSlot,
 102         p_ia_ul_config_req->sSFN_Slot.nSym, is_urllc));
 103
 104     return SUCCESS;
 105 }
 106
 107 static uint32_t get_rbg_index_mask_from_LSB(uint32_t nth_bit) {
 108     #define ULSCH_RBG_INDEX_LSB 0x1u
 109     return ULSCH_RBG_INDEX_LSB << nth_bit;
 110 }
 111
 112  /** @ingroup group_source_api_p7_fapi2phy_proc
 113  *
 114  *  @param[in]  rb_bitmap Pointer to FAPI DL resource block bitmap.
 115  *  @param[in]  rbg_size  Size of resource block group.
 116  *
 117  *  @return     Returns IAPI nRBGIndex
 118  *
 119  *  @description
 120  *  Maps rbBitmap into nRBGIndex bits for pusch.
 121  *
 122 **/
 123 uint32_t nr5g_fapi_calc_pusch_rbg_index(
 124     const uint8_t rb_bitmap[FAPI_RB_BITMAP_SIZE],
 125     uint16_t bwp_start,
 126     uint16_t bwp_size
 127     )
 128 {
 129     return nr5g_fapi_calc_rbg_index(
 130         rb_bitmap, bwp_start, bwp_size, get_rbg_index_mask_from_LSB);
 131 }
 132
 133  /** @ingroup group_source_api_p7_fapi2phy_proc
 134  *
 135  *  @param[in]  p_pusch_data Pointer to FAPI Optional PUSCH Data structure.
 136  *  @param[in]  p_ul_data_chan Pointer to IAPI ULSCH PDU structure.
 137  *
 138  *  @return     None.
 139  *
 140  *  @description
 141  *  This function converts FAPI UL_TTI.request's Optional PUSCH Data to IAPI UL_Config.request's
 142  *  ULSCH PDU structure.
 143  *
 144 **/
 145 void nr5g_fapi_pusch_data_to_phy_ulsch_translation(
 146     nr5g_fapi_pusch_info_t * p_pusch_info,
 147     fapi_pusch_data_t * p_pusch_data,
 148     ULSCHPDUStruct * p_ul_data_chan)
 149 {
 150     p_ul_data_chan->nRV = p_pusch_data->rvIndex;
 151     p_pusch_info->harq_process_id = p_ul_data_chan->nHARQID =
 152         p_pusch_data->harqProcessId;
 153     p_ul_data_chan->nNDI = p_pusch_data->newDataIndicator;
 154     p_ul_data_chan->nTBSize = p_pusch_data->tbSize;
 155     //numCb and cbPresentAndPoistion[] is ignored as per design
 156 }
 157
 158  /** @ingroup group_source_api_p7_fapi2phy_proc
 159  *
 160  *  @param[in]  p_pusch_uci Pointer to FAPI Optional PUSCH UCI structure.
 161  *  @param[in]  p_ul_data_chan Pointer to IAPI ULSCH PDU structure.
 162  *
 163  *  @return     None.
 164  *
 165  *  @description
 166  *  This function converts FAPI UL_TTI.request's Optional PUSCH UCI to IAPI UL_Config.request's
 167  *  ULSCH PDU structure.
 168  *
 169 **/
 170 void nr5g_fapi_pusch_uci_to_phy_ulsch_translation(
 171     fapi_pusch_uci_t * p_pusch_uci,
 172     ULSCHPDUStruct * p_ul_data_chan)
 173 {
 174     p_ul_data_chan->nAck = p_pusch_uci->harqAckBitLength;
 175     p_ul_data_chan->nAlphaScaling = p_pusch_uci->alphaScaling;
 176     p_ul_data_chan->nBetaOffsetACKIndex = p_pusch_uci->betaOffsetHarqAck;
 177     p_ul_data_chan->nBetaOffsetCSIP1Index = p_pusch_uci->betaOffsetCsi1;
 178     p_ul_data_chan->nBetaOffsetCSIP2Index = p_pusch_uci->betaOffsetCsi2;
 179     p_ul_data_chan->nCSIPart1 = p_pusch_uci->csiPart1BitLength;
 180     p_ul_data_chan->nCSIPart2 = p_pusch_uci->csiPart2BitLength;
 181 }
 182
 183 /** @ingroup group_source_api_p7_fapi2phy_proc
 184  *
 185  *  @param[in]  p_pusch_ptrs Pointer to FAPI Optional PUSCH PTRS structure.
 186  *  @param[in]  p_ul_data_chan Pointer to IAPI ULSCH PDU structure.
 187  *
 188  *  @return     None.
 189  *
 190  *  @description
 191  *  This function converts FAPI UL_TTI.request's Optional PUSCH PTRS to IAPI UL_Config.request's
 192  *  ULSCH PDU structure.
 193  *
 194 **/
 195 void nr5g_fapi_pusch_ptrs_to_phy_ulsch_translation(
 196     fapi_pusch_ptrs_t * p_pusch_ptrs,
 197     ULSCHPDUStruct * p_ul_data_chan)
 198 {
 199     uint8_t i, num_ptrs_ports = 0, port_index = 0;
 200     fapi_ptrs_info_t *p_ptrs_info;
 201
 202     if (p_pusch_ptrs->ptrsTimeDensity <= 2) {
 203         p_ul_data_chan->nPTRSTimeDensity =
 204             pow(2, p_pusch_ptrs->ptrsTimeDensity);
 205     }
 206     if (p_pusch_ptrs->ptrsFreqDensity == 0 ||
 207         p_pusch_ptrs->ptrsFreqDensity == 1) {
 208         p_ul_data_chan->nPTRSFreqDensity =
 209             pow(2, (p_pusch_ptrs->ptrsFreqDensity + 1));
 210     }
 211     if (p_pusch_ptrs->numPtrsPorts > 0) {
 212         num_ptrs_ports = p_ul_data_chan->nNrOfPTRSPorts = 1;
 213     }
 214     for (i = 0; i < num_ptrs_ports && i < FAPI_MAX_PTRS_PORTS; i++) {
 215         p_ptrs_info = &p_pusch_ptrs->ptrsInfo[i];
 216         for (port_index = 0; port_index < NUM_UL_PTRS_PORT_INDEX; port_index++)
 217         {
 218             if ((p_ptrs_info->ptrsPortIndex >> port_index) & 0x01) {
 219                 p_ul_data_chan->nPTRSPortIndex[i] = port_index;
 220             }
 221         }
 222         //PTRSDmrsPort is ignored as per Design
 223         p_ul_data_chan->nPTRSReOffset = p_ptrs_info->ptrsReOffset;
 224     }
 225 }
 226
 227  /** @ingroup group_source_api_p7_fapi2phy_proc
 228  *
 229  *  @param[in]  p_phy_instance Pointer to PHY instance.
 230  *  @param[in]  p_pusch_pdu Pointer to FAPI PUSCH PDU structure.
 231  *  @param[out]  p_ul_data_chan Pointer to IAPI ULSCH PDU structure.
 232  *
 233  *  @return     None.
 234  *
 235  *  @description
 236  *  This function converts FAPI UL_TTI.request's PUSCH PDU to IAPI UL_Config.request's
 237  *  ULSCH PDU structure.
 238  *
 239 **/
 240 void nr5g_fapi_pusch_to_phy_ulsch_translation(
 241     p_nr5g_fapi_phy_instance_t p_phy_instance,
 242     nr5g_fapi_pusch_info_t * p_pusch_info,
 243     fapi_ul_pusch_pdu_t * p_pusch_pdu,
 244     ULSCHPDUStruct * p_ul_data_chan)
 245 {
 246     uint8_t mcs_table, nr_of_layers, n_rbg_size;
 247     uint8_t i, port_index = 0;
 248     uint16_t dmrs_ports, bwp_size, bwp_start, pdu_bitmap;
 249     nr5g_fapi_stats_t *p_stats;
 250
 251     p_stats = &p_phy_instance->stats;
 252     p_stats->fapi_stats.fapi_ul_tti_pusch_pdus++;
 253
 254     NR5G_FAPI_MEMSET(p_ul_data_chan, sizeof(ULSCHPDUStruct), 0,
 255         sizeof(ULSCHPDUStruct));
 256
 257     p_ul_data_chan->sPDUHdr.nPDUType = UL_PDU_TYPE_ULSCH;
 258     p_ul_data_chan->sPDUHdr.nPDUSize = RUP32B(sizeof(ULSCHPDUStruct));
 259
 260     p_ul_data_chan->nRNTI = p_pusch_pdu->rnti;
 261
 262     p_pusch_info->handle = p_ul_data_chan->nUEId =
 263         (uint16_t) p_pusch_pdu->handle;
 264
 265     bwp_size = p_ul_data_chan->nBWPSize = p_pusch_pdu->bwpSize;
 266     bwp_start = p_ul_data_chan->nBWPStart = p_pusch_pdu->bwpStart;
 267
 268     p_ul_data_chan->nSubcSpacing = p_pusch_pdu->subCarrierSpacing;
 269     p_ul_data_chan->nCpType = p_pusch_pdu->cyclicPrefix;
 270     p_ul_data_chan->nMCS = p_pusch_pdu->mcsIndex;
 271     p_ul_data_chan->nTransPrecode = !(p_pusch_pdu->transformPrecoding);
 272     mcs_table = p_pusch_pdu->mcsTable;
 273     if (mcs_table <= 2) {
 274         p_ul_data_chan->nMcsTable = mcs_table;
 275     }
 276     if ((mcs_table > 2) && (mcs_table <= 4)) {
 277         p_ul_data_chan->nTransPrecode = 1;
 278
 279         if (mcs_table == 3) {
 280             p_ul_data_chan->nMcsTable = 0;
 281         } else {
 282             p_ul_data_chan->nMcsTable = 2;
 283         }
 284     }
 285
 286     p_ul_data_chan->nNid = p_pusch_pdu->dataScramblingId;
 287     p_ul_data_chan->nDMRSConfigType = p_pusch_pdu->dmrsConfigType;
 288     p_ul_data_chan->nMappingType = p_pusch_pdu->mappingType;
 289     p_ul_data_chan->nNrOfDMRSSymbols = p_pusch_pdu->nrOfDmrsSymbols;
 290     p_ul_data_chan->nDMRSAddPos = p_pusch_pdu->dmrsAddPos;
 291     p_ul_data_chan->nNIDnSCID = p_pusch_pdu->ulDmrsScramblingId;
 292     p_ul_data_chan->nSCID = p_pusch_pdu->scid;
 293     p_ul_data_chan->nNrOfCDMs = p_pusch_pdu->numDmrsCdmGrpsNoData;
 294
 295     dmrs_ports = p_pusch_pdu->dmrsPorts;
 296     nr_of_layers = p_ul_data_chan->nNrOfLayers = p_pusch_pdu->nrOfLayers;
 297     for (i = 0; (i < FAPI_MAX_DMRS_PORTS && port_index < nr_of_layers); i++) {
 298         if (port_index < FAPI_MAX_UL_LAYERS) {
 299             if ((dmrs_ports >> i) & 0x0001) {
 300                 p_ul_data_chan->nPortIndex[port_index++] = i;
 301             }
 302         } else {
 303             break;
 304         }
 305     }
 306     p_ul_data_chan->nTPPuschID = p_pusch_pdu->nTpPuschId;
 307     p_ul_data_chan->nTpPi2BPSK = p_pusch_pdu->tpPi2Bpsk;
 308
 309     // Resource Allocation Information
 310     p_ul_data_chan->nResourceAllocType = p_pusch_pdu->resourceAlloc;
 311     if(FAPI_UL_RESOURCE_ALLOC_TYPE_0 == p_pusch_pdu->resourceAlloc) {
 312         // TODO HS check correctness of supporting only config1
 313     //Config-1 alone is supported
 314         n_rbg_size = p_ul_data_chan->nRBGSize =
 315             nr5g_fapi_calc_n_rbg_size(bwp_size);
 316     if (n_rbg_size > 0) {
 317         p_ul_data_chan->nNrOfRBGs =
 318             ceil((bwp_size + (bwp_start % n_rbg_size)) / n_rbg_size);
 319     }
 320         p_ul_data_chan->nRBGIndex = nr5g_fapi_calc_pusch_rbg_index(
 321             p_pusch_pdu->rbBitmap, bwp_start, bwp_size);
 322     }
 323     p_ul_data_chan->nRBStart = p_pusch_pdu->rbStart;
 324     p_ul_data_chan->nRBSize = p_pusch_pdu->rbSize;
 325     p_ul_data_chan->nVRBtoPRB = p_pusch_pdu->vrbToPrbMapping;
 326     p_ul_data_chan->nStartSymbolIndex = p_pusch_pdu->startSymbIndex;
 327     p_ul_data_chan->nNrOfSymbols = p_pusch_pdu->nrOfSymbols;
 328
 329     p_ul_data_chan->nPTRSPresent = 0;
 330     pdu_bitmap = p_pusch_pdu->pduBitMap;
 331     if (pdu_bitmap & 0x01) {
 332         nr5g_fapi_pusch_data_to_phy_ulsch_translation(p_pusch_info,
 333             &p_pusch_pdu->puschData, p_ul_data_chan);
 334     }
 335     if (pdu_bitmap & 0x02) {
 336         nr5g_fapi_pusch_uci_to_phy_ulsch_translation(&p_pusch_pdu->puschUci,
 337             p_ul_data_chan);
 338     }
 339     if (pdu_bitmap & 0x04) {
 340         nr5g_fapi_pusch_ptrs_to_phy_ulsch_translation(&p_pusch_pdu->puschPtrs,
 341             p_ul_data_chan);
 342     }
 343     if ((pdu_bitmap & (1 << 15))) {
 344         p_ul_data_chan->nPTRSPresent = 1;
 345     }
 346     p_ul_data_chan->nULType = 0;
 347     p_ul_data_chan->nRBBundleSize = 0;
 348     p_ul_data_chan->nPMI = 0;
 349     p_ul_data_chan->nTransmissionScheme = 0;
 350     p_ul_data_chan->rsv1 = 0;
 351
 352     p_ul_data_chan->nNrOfAntennaPorts = 1;
 353     p_ul_data_chan->nNrofRxRU = 1;
 354
 355     p_stats->iapi_stats.iapi_ul_tti_pusch_pdus++;
 356 }
 357
 358  /** @ingroup group_source_api_p7_fapi2phy_proc
 359  *
 360  *  @param[in]  p_phy_instance Pointer to PHY instance.
 361  *  @param[in]  p_pucch_pdu Pointer to FAPI PUSCH PDU structure.
 362  *  @param[in]  p_ul_ctrl_chan Pointer to IAPI ULCCH_UCIPDU structure.
 363  *
 364  *  @return     None.
 365  *
 366  *  @description
 367  *  This function converts FAPI UL_TTI.request's PUCCH PDU to IAPI UL_Config.request's
 368  *  ULCCH_UCI PDU structure.
 369  *
 370 **/
 371 void nr5g_fapi_pucch_to_phy_ulcch_uci_translation(
 372     p_nr5g_fapi_phy_instance_t p_phy_instance,
 373     nr5g_fapi_pucch_info_t * p_pucch_info,
 374     fapi_ul_pucch_pdu_t * p_pucch_pdu,
 375     ULCCHUCIPDUStruct * p_ul_ctrl_chan)
 376 {
 377     nr5g_fapi_stats_t *p_stats;
 378     p_stats = &p_phy_instance->stats;
 379     p_stats->fapi_stats.fapi_ul_tti_pucch_pdus++;
 380     NR5G_FAPI_MEMSET(p_ul_ctrl_chan, sizeof(ULCCHUCIPDUStruct), 0,
 381         sizeof(ULCCHUCIPDUStruct));
 382     p_ul_ctrl_chan->sPDUHdr.nPDUType = UL_PDU_TYPE_ULCCH_UCI;
 383     p_ul_ctrl_chan->sPDUHdr.nPDUSize = RUP32B(sizeof(ULCCHUCIPDUStruct));
 384
 385     p_ul_ctrl_chan->nRNTI = p_pucch_pdu->rnti;
 386     p_pucch_info->handle = p_ul_ctrl_chan->nUEId =
 387         (uint16_t) p_pucch_pdu->handle;
 388
 389     p_ul_ctrl_chan->nBWPSize = p_pucch_pdu->bwpSize;
 390     p_ul_ctrl_chan->nBWPStart = p_pucch_pdu->bwpStart;
 391     p_ul_ctrl_chan->nSubcSpacing = p_pucch_pdu->subCarrierSpacing;
 392     p_ul_ctrl_chan->nCpType = p_pucch_pdu->cyclicPrefix;
 393     p_pucch_info->pucch_format = p_ul_ctrl_chan->nFormat =
 394         p_pucch_pdu->formatType;
 395     if (p_pucch_pdu->pi2Bpsk) {
 396         p_ul_ctrl_chan->modType = 1;
 397     } else {                    //QPSK
 398         p_ul_ctrl_chan->modType = 2;
 399     }
 400     p_ul_ctrl_chan->nStartPRB = p_pucch_pdu->prbStart;
 401     p_ul_ctrl_chan->nPRBs = p_pucch_pdu->prbSize;
 402     p_ul_ctrl_chan->nStartSymbolx = p_pucch_pdu->startSymbolIndex;
 403     p_ul_ctrl_chan->nSymbols = p_pucch_pdu->nrOfSymbols;
 404     p_ul_ctrl_chan->nFreqHopFlag = p_pucch_pdu->freqHopFlag;
 405
 406     p_ul_ctrl_chan->n2ndHopPRB = p_pucch_pdu->secondHopPrb;
 407     p_ul_ctrl_chan->nM0 = p_pucch_pdu->initialCyclicShift;
 408     p_ul_ctrl_chan->nID = p_pucch_pdu->dataScramblingId;
 409     p_ul_ctrl_chan->nFmt1OrthCCodeIdx = p_pucch_pdu->timeDomainOccIdx;
 410     p_ul_ctrl_chan->nFmt4OrthCCodeIdx = p_pucch_pdu->preDftOccIdx;
 411     p_ul_ctrl_chan->nFmt4OrthCCodeLength = p_pucch_pdu->preDftOccLen;
 412     p_ul_ctrl_chan->nAddDmrsFlag = p_pucch_pdu->addDmrsFlag;
 413     p_ul_ctrl_chan->nScramID = p_pucch_pdu->dmrsScramblingId;
 414     p_ul_ctrl_chan->nSRPriodAriv = p_pucch_pdu->srFlag;
 415     p_ul_ctrl_chan->nBitLenUci = p_pucch_pdu->bitLenHarq;
 416
 417     p_ul_ctrl_chan->nNrofRxRU = 1;
 418
 419     p_stats->iapi_stats.iapi_ul_tti_pucch_pdus++;
 420 }
 421
 422 /** @ingroup group_source_api_p7_fapi2phy_proc
 423  *
 424  *  @param[in]  p_srs_pdu Pointer to FAPI SRS PDU structure.
 425  *  @param[in]  p_ul_srs_chan Pointer to IAPI SRS PDU structure.
 426  *
 427  *  @return     None.
 428  *
 429  *  @description
 430  *  This function converts FAPI UL_TTI.request's SRS PDU to IAPI UL_Config.request's
 431  *  SRS PDU structure.
 432  *
 433 **/
 434 void nr5g_fapi_srs_to_phy_srs_translation(
 435     p_nr5g_fapi_phy_instance_t p_phy_instance,
 436     fapi_ul_srs_pdu_t * p_srs_pdu,
 437     nr5g_fapi_srs_info_t * p_srs_info,
 438     SRSPDUStruct * p_ul_srs_chan)
 439 {
 440     nr5g_fapi_stats_t *p_stats;
 441
 442     p_stats = &p_phy_instance->stats;
 443     p_stats->fapi_stats.fapi_ul_tti_srs_pdus++;
 444     NR5G_FAPI_MEMSET(p_ul_srs_chan, sizeof(SRSPDUStruct), 0,
 445         sizeof(SRSPDUStruct));
 446     p_ul_srs_chan->sPDUHdr.nPDUType = UL_PDU_TYPE_SRS;
 447     p_ul_srs_chan->sPDUHdr.nPDUSize = RUP32B(sizeof(SRSPDUStruct));
 448
 449     p_ul_srs_chan->nRNTI = p_srs_pdu->rnti;
 450     p_srs_info->handle = p_ul_srs_chan->nUEId = (uint16_t) p_srs_pdu->handle;
 451
 452     p_ul_srs_chan->nSubcSpacing = p_srs_pdu->subCarrierSpacing;
 453     p_ul_srs_chan->nCpType = p_srs_pdu->cyclicPrefix;
 454     p_ul_srs_chan->nNrOfSrsPorts = pow(2, p_srs_pdu->numAntPorts);
 455     p_ul_srs_chan->nNrOfSymbols = pow(2, p_srs_pdu->numSymbols);
 456     p_ul_srs_chan->nRepetition = pow(2, p_srs_pdu->numRepetitions);
 457     if (p_ul_srs_chan->nCpType) {   //Extended Cyclic Prefix
 458         p_ul_srs_chan->nStartPos = 11 - p_srs_pdu->timeStartPosition;
 459     } else {
 460         p_ul_srs_chan->nStartPos = 13 - p_srs_pdu->timeStartPosition;
 461     }
 462     p_ul_srs_chan->nCsrs = p_srs_pdu->configIndex;
 463     p_ul_srs_chan->nBsrs = p_srs_pdu->bandwidthIndex;
 464     p_ul_srs_chan->nSrsId = p_srs_pdu->sequenceId;
 465
 466     if (p_srs_pdu->combSize) {
 467         p_ul_srs_chan->nComb = 4;
 468     } else {
 469         p_ul_srs_chan->nComb = 2;
 470     }
 471     p_ul_srs_chan->nCombOffset = p_srs_pdu->combOffset;
 472     p_ul_srs_chan->nCyclicShift = p_srs_pdu->cyclicShift;
 473     p_ul_srs_chan->nFreqPos = p_srs_pdu->frequencyPosition;
 474     p_ul_srs_chan->nFreqShift = p_srs_pdu->frequencyShift;
 475     p_ul_srs_chan->nBHop = p_srs_pdu->frequencyHopping;
 476     p_ul_srs_chan->nHopping = p_srs_pdu->groupOrSequenceHopping;
 477     p_ul_srs_chan->nResourceType = p_srs_pdu->resourceType;
 478     p_ul_srs_chan->nTsrs = p_srs_pdu->tSrs;
 479     p_ul_srs_chan->nToffset = p_srs_pdu->tOffset;
 480     p_ul_srs_chan->nToffset = p_srs_pdu->tOffset;
 481
 482     p_ul_srs_chan->nNrofRxRU = 1;
 483
 484     p_stats->iapi_stats.iapi_ul_tti_srs_pdus++;
 485 }
 486
 487  /** @ingroup group_source_api_p7_fapi2phy_proc
 488  *
 489  *  @param[in]  p_fapi_req Pointer to FAPI UL_TTI.request structure.
 490  *  @param[in]  p_ia_ul_config_req Pointer to IAPI UL_TTI.request structure.
 491  *
 492  *  @return     Returns ::SUCCESS and ::FAILURE.
 493  *
 494  *  @description
 495  *  This function converts FAPI UL_TTI.request to IAPI UL_Config.request
 496  *  structure.
 497  *
 498 **/
 499 uint8_t nr5g_fapi_ul_tti_req_to_phy_translation(
 500     bool is_urllc,
 501     p_nr5g_fapi_phy_instance_t p_phy_instance,
 502     fapi_ul_tti_req_t * p_fapi_req,
 503     fapi_vendor_msg_t * p_fapi_vendor_msg,
 504     PULConfigRequestStruct p_ia_ul_config_req)
 505 {
 506     uint8_t i, j;
 507     uint8_t num_fapi_pdus, num_groups, num_ue = 0u;
 508     uint16_t frame_no;
 509     uint8_t slot_no, symbol_no;
 510
 511     fapi_ul_tti_req_pdu_t *p_fapi_ul_tti_req_pdu;
 512     fapi_ue_info_t *p_fapi_ue_grp_info;
 513     ULSCHPDUStruct *p_ul_data_chan;
 514     ULCCHUCIPDUStruct *p_ul_ctrl_chan;
 515     SRSPDUStruct *p_ul_srs_chan;
 516     PUSCHGroupInfoStruct *p_pusch_grp_info;
 517     PDUStruct *p_pdu_head;
 518     nr5g_fapi_ul_slot_info_t *p_ul_slot_info;
 519     nr5g_fapi_stats_t *p_stats;
 520
 521     p_stats = &p_phy_instance->stats;
 522
 523     frame_no = p_ia_ul_config_req->sSFN_Slot.nSFN = p_fapi_req->sfn;
 524     slot_no = p_ia_ul_config_req->sSFN_Slot.nSlot = p_fapi_req->slot;
 525     p_ia_ul_config_req->sSFN_Slot.nCarrierIdx = p_phy_instance->phy_id;
 526
 527     if (FAILURE == nr5g_fapi_ul_tti_req_to_phy_translation_vendor_ext_symbol_no(is_urllc,
 528                                         p_fapi_vendor_msg, p_ia_ul_config_req, &symbol_no))
 529     {
 530         return FAILURE;
 531     }
 532
 533     p_ul_slot_info =
 534        &p_phy_instance->ul_slot_info[is_urllc]
 535             [(slot_no % MAX_UL_SLOT_INFO_COUNT)]
 536             [symbol_no % MAX_UL_SYMBOL_INFO_COUNT];// TODO:  will be split in 2 in a separate MR, as non-urllc does not need symbol info
 537
 538     nr5g_fapi_set_ul_slot_info(frame_no, slot_no, symbol_no, p_ul_slot_info);
 539
 540     num_fapi_pdus = p_ia_ul_config_req->nPDU = p_fapi_req->nPdus;
 541     num_groups = p_ia_ul_config_req->nGroup = p_fapi_req->nGroup;
 542     p_ia_ul_config_req->nUlsch = p_fapi_req->nUlsch;
 543     p_ia_ul_config_req->nUlcch = p_fapi_req->nUlcch;
 544     p_ia_ul_config_req->nRachPresent = p_fapi_req->rachPresent;
 545     if (p_fapi_req->rachPresent) {
 546         p_ul_slot_info->rach_presence = 1;
 547         p_ul_slot_info->rach_info.phy_cell_id =
 548             p_phy_instance->phy_config.phy_cell_id;
 549     }
 550     p_ia_ul_config_req->nUlsrs = 0;
 551     for (i = 0u; i < num_groups; i++) {
 552         p_pusch_grp_info = &p_ia_ul_config_req->sPUSCHGroupInfoStruct[i];
 553         p_fapi_ue_grp_info = &p_fapi_req->ueGrpInfo[i];
 554         num_ue = p_pusch_grp_info->nUE = p_fapi_ue_grp_info->nUe;
 555         for (j = 0u; j < num_ue; j++) {
 556             p_pusch_grp_info->nPduIdx[j] = p_fapi_ue_grp_info->pduIdx[j];
 557         }
 558     }
 559     p_pdu_head =
 560         (PDUStruct *) ((uint8_t *) p_ia_ul_config_req +
 561         sizeof(ULConfigRequestStruct));
 562
 563     for (i = 0; i < num_fapi_pdus; i++) {
 564         p_pdu_head->nPDUSize = 0;
 565         p_stats->fapi_stats.fapi_ul_tti_pdus++;
 566         p_fapi_ul_tti_req_pdu = &p_fapi_req->pdus[i];
 567
 568         switch (p_fapi_ul_tti_req_pdu->pduType) {
 569             case FAPI_PRACH_PDU_TYPE:
 570                 {
 571                     p_ia_ul_config_req->nPDU--;
 572                     p_stats->fapi_stats.fapi_ul_tti_prach_pdus++;
 573                 }
 574                 break;
 575
 576             case FAPI_PUSCH_PDU_TYPE:
 577                 {
 578                     p_ul_data_chan = (ULSCHPDUStruct *) p_pdu_head;
 579                     nr5g_fapi_pusch_to_phy_ulsch_translation(p_phy_instance,
 580                         &p_ul_slot_info->pusch_info[p_ul_slot_info->num_ulsch],
 581                         &p_fapi_ul_tti_req_pdu->pdu.pusch_pdu,
 582                         p_ul_data_chan);
 583                     p_ul_slot_info->num_ulsch++;
 584                 }
 585                 break;
 586
 587             case FAPI_PUCCH_PDU_TYPE:
 588                 {
 589                     p_ul_ctrl_chan = (ULCCHUCIPDUStruct *) p_pdu_head;
 590                     nr5g_fapi_pucch_to_phy_ulcch_uci_translation(p_phy_instance,
 591                         &p_ul_slot_info->pucch_info[p_ul_slot_info->num_ulcch],
 592                         &p_fapi_ul_tti_req_pdu->pdu.pucch_pdu,
 593                         p_ul_ctrl_chan);
 594                     p_ul_slot_info->num_ulcch++;
 595                 }
 596                 break;
 597
 598             case FAPI_SRS_PDU_TYPE:
 599                 {
 600                     p_ia_ul_config_req->nUlsrs++;
 601                     p_ul_srs_chan = (SRSPDUStruct *) p_pdu_head;
 602                     nr5g_fapi_srs_to_phy_srs_translation(p_phy_instance,
 603                         &p_fapi_ul_tti_req_pdu->pdu.srs_pdu,
 604                         &p_ul_slot_info->srs_info[p_ul_slot_info->num_srs],
 605                         p_ul_srs_chan);
 606                     p_ul_slot_info->num_srs++;
 607                 }
 608                 break;
 609
 610             default:
 611                 {
 612                     NR5G_FAPI_LOG(ERROR_LOG,
 613                         ("[NR5G_FAPI] [UL_TTI.request] Unknown PDU Type :%d",
 614                             p_fapi_ul_tti_req_pdu->pduType));
 615                     return FAILURE;
 616                 }
 617         }
 618         p_pdu_head =
 619             (PDUStruct *) ((uint8_t *) p_pdu_head + p_pdu_head->nPDUSize);
 620         p_stats->iapi_stats.iapi_ul_tti_pdus++;
 621     }
 622
 623     if (NULL != p_fapi_vendor_msg) {
 624         nr5g_fapi_ul_tti_req_to_phy_translation_vendor_ext(p_fapi_vendor_msg,
 625                                                            p_ia_ul_config_req);
 626     }
 627
 628     return SUCCESS;
 629 }
 630
 631  /** @ingroup group_source_api_p7_fapi2phy_proc
 632  *
 633  *  @param[in]  p_fapi_vendor_msg  Pointer to FAPI UL_TTI.request vendor message.
 634  *  @param[in]  p_ia_ul_config_req Pointer to IAPI UL_TTI.request structure.
 635  *
 636  *  @return     no return.
 637  *
 638  *  @description
 639  *  This function fills fields for UL_TTI.request structure that come from
 640  *  a vendor extension.
 641  *
 642 **/
 643 void nr5g_fapi_ul_tti_req_to_phy_translation_vendor_ext(
 644     fapi_vendor_msg_t * p_fapi_vendor_msg,
 645     PULConfigRequestStruct p_ia_ul_config_req)
 646 {
 647     uint8_t i = 0u;
 648
 649     fapi_vendor_ul_tti_req_t *p_vendor_ul_tti_req = NULL;
 650     fapi_vendor_ul_tti_req_pdu_t *p_fapi_vendor_ul_tti_req_pdu = NULL;
 651     fapi_vendor_ul_pusch_pdu_t *p_vendor_pusch_pdu = NULL;
 652     fapi_vendor_ul_pucch_pdu_t *p_vendor_pucch_pdu = NULL;
 653     fapi_vendor_ul_srs_pdu_t *p_vendor_srs_pdu = NULL;
 654
 655     ULSCHPDUStruct *p_ul_data_chan;
 656     ULCCHUCIPDUStruct *p_ul_ctrl_chan;
 657     SRSPDUStruct *p_ul_srs_chan;
 658     PDUStruct *p_pdu_head;
 659
 660     p_vendor_ul_tti_req = &p_fapi_vendor_msg->p7_req_vendor.ul_tti_req;
 661
 662     p_pdu_head = p_ia_ul_config_req->sULPDU;
 663
 664     for (i = 0u; i < p_ia_ul_config_req->nPDU; i++) {
 665         p_fapi_vendor_ul_tti_req_pdu = &p_vendor_ul_tti_req->ul_pdus[i];
 666
 667         switch (p_pdu_head->nPDUType) {
 668             case UL_PDU_TYPE_PRACH:
 669                 // Not used
 670                 break;
 671
 672             case UL_PDU_TYPE_ULSCH:
 673                 {
 674                     p_ul_data_chan = (ULSCHPDUStruct *) p_pdu_head;
 675                     p_vendor_pusch_pdu = &p_fapi_vendor_ul_tti_req_pdu->pdu.pusch_pdu;
 676
 677                     p_ul_data_chan->nNrOfAntennaPorts = p_vendor_pusch_pdu->nr_of_antenna_ports;
 678                     p_ul_data_chan->nNrofRxRU = p_vendor_pusch_pdu->nr_of_rx_ru;
 679                     NR5G_FAPI_MEMCPY(p_ul_data_chan->nRxRUIdx, sizeof(p_ul_data_chan->nRxRUIdx),
 680                                     p_vendor_pusch_pdu->rx_ru_idx, sizeof(p_vendor_pusch_pdu->rx_ru_idx));
 681                 }
 682                 break;
 683
 684             case UL_PDU_TYPE_ULCCH_UCI:
 685                 {
 686                     p_ul_ctrl_chan = (ULCCHUCIPDUStruct *) p_pdu_head;
 687                     p_vendor_pucch_pdu = &p_fapi_vendor_ul_tti_req_pdu->pdu.pucch_pdu;
 688
 689                     p_ul_ctrl_chan->nNrofRxRU = p_vendor_pucch_pdu->nr_of_rx_ru;
 690                     p_ul_ctrl_chan->nGroupId = p_vendor_pucch_pdu->group_id;
 691                     NR5G_FAPI_MEMCPY(p_ul_ctrl_chan->nRxRUIdx, sizeof(p_ul_ctrl_chan->nRxRUIdx),
 692                                         p_vendor_pucch_pdu->rx_ru_idx, sizeof(p_vendor_pucch_pdu->rx_ru_idx));
 693                 }
 694                 break;
 695
 696             case UL_PDU_TYPE_SRS:
 697                 {
 698                     p_ul_srs_chan = (SRSPDUStruct *) p_pdu_head;
 699                     p_vendor_srs_pdu = &p_fapi_vendor_ul_tti_req_pdu->pdu.srs_pdu;
 700
 701                     p_ul_srs_chan->nNrofRxRU = p_vendor_srs_pdu->nr_of_rx_ru;
 702                     NR5G_FAPI_MEMCPY(p_ul_srs_chan->nRxRUIdx, sizeof(p_ul_srs_chan->nRxRUIdx),
 703                                     p_vendor_srs_pdu->rx_ru_idx, sizeof(p_vendor_srs_pdu->rx_ru_idx));
 704                 }
 705                 break;
 706
 707             default:
 708                 {
 709                     NR5G_FAPI_LOG(ERROR_LOG,
 710                         ("[NR5G_FAPI] [UL_TTI.request] Unknown PDU Type :%d",
 711                             p_ia_ul_config_req->sMsgHdr.nMessageType));
 712                     return;
 713                 }
 714         }
 715         p_pdu_head =
 716             (PDUStruct *) ((uint8_t *) p_pdu_head + p_pdu_head->nPDUSize);
 717     }
 718 }
 719
 720
 721  /** @ingroup group_source_api_p7_fapi2phy_proc
 722  *
 723  *  @param[in]  p_fapi_vendor_msg  Pointer to FAPI UL_TTI.request vendor message.
 724  *  @param[in]  p_ia_ul_config_req Pointer to IAPI UL_TTI.request structure.
 725  *
 726  *  @return     Returns ::SUCCESS and ::FAILURE.
 727  *
 728  *  @description
 729  *  This function fills symbol_no field for UL_TTI.request structure and fails if
 730  *  the mode is urllc and there is no associated vendor_msg.
 731  *
 732 **/
 733 uint8_t nr5g_fapi_ul_tti_req_to_phy_translation_vendor_ext_symbol_no(
 734     bool is_urllc,
 735     fapi_vendor_msg_t * p_fapi_vendor_msg,
 736     PULConfigRequestStruct p_ia_ul_config_req,
 737     uint8_t* symbol_no)
 738 {
 739     // for non-urllc mode symbol_no is a don't care
 740     *symbol_no = 0u;
 741     if (is_urllc)
 742     {
 743         if (NULL == p_fapi_vendor_msg)
 744         {
 745             NR5G_FAPI_LOG(ERROR_LOG, ("[NR5G_FAPI][UL_TTI.request] No vendor ext for URLLC! "
 746                     "_vendor_ul_tti_req"));
 747             return FAILURE;
 748         }
 749         *symbol_no = p_ia_ul_config_req->sSFN_Slot.nSym = p_fapi_vendor_msg->p7_req_vendor.ul_tti_req.sym;
 750     }
 751     return SUCCESS;
 752 }