+ * Function : BuildSearchSpcToAddModList
+ *
+ * Functionality: Build search space to add/modify list
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
+{
+ uint8_t idx;
+ uint8_t numBytes;
+ uint8_t byteIdx;
+ uint8_t bitsUnused;
+ uint8_t elementCnt;
+ struct SearchSpace *searchSpc;
+
+ if(pdcchCfg == NULLP)
+ elementCnt = 1;
+ else
+ elementCnt = pdcchCfg->numSearchSpcToAddMod;
+
+ searchSpcList->list.count = elementCnt;
+ searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
+
+ searchSpcList->list.array = NULLP;
+ DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
+ if(!searchSpcList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ searchSpcList->list.array[idx] = NULLP;
+ DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
+ if(!searchSpcList->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ searchSpc = searchSpcList->list.array[idx];
+
+ if(pdcchCfg == NULLP)
+ searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
+ else
+ searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
+
+ searchSpc->controlResourceSetId = NULLP;
+ DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
+ if(!searchSpc->controlResourceSetId)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ if(pdcchCfg == NULLP)
+ *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
+ else
+ *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
+
+ searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
+ DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
+ if(!searchSpc->monitoringSlotPeriodicityAndOffset)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ if(pdcchCfg == NULLP)
+ searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
+ else
+ {
+ searchSpc->monitoringSlotPeriodicityAndOffset->present = \
+ pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset.mSlotPeriodicity;
+ BuildSearchSpcSlotOffset(searchSpc->monitoringSlotPeriodicityAndOffset, \
+ pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset.mSlotOffset);
+ }
+
+ searchSpc->duration = NULLP;
+ searchSpc->monitoringSymbolsWithinSlot = NULLP;
+ DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
+ if(!searchSpc->monitoringSymbolsWithinSlot)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+
+ /* Values taken from reference logs :
+ * size 2 bytes
+ * 2 LSBs unsued
+ * Bit string stores 8000
+ */
+ numBytes = 2;
+ bitsUnused = 2;
+ searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
+ searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
+ DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
+ if(!searchSpc->monitoringSymbolsWithinSlot->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ if(pdcchCfg == NULLP)
+ {
+ byteIdx = 0;
+ searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
+ searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
+ }
+ else
+ memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
+ searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
+
+ searchSpc->nrofCandidates = NULLP;
+ DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
+ if(!searchSpc->nrofCandidates)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+
+ if(pdcchCfg == NULLP)
+ {
+ searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
+ searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
+ searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
+ searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
+ searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
+ }
+ else
+ {
+ searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
+ searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
+ searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
+ searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
+ searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
+ }
+
+ searchSpc->searchSpaceType = NULLP;
+ DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
+ if(!searchSpc->searchSpaceType)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ if(pdcchCfg == NULLP)
+ searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
+ else
+ searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
+
+ searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
+ DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
+ if(!searchSpc->searchSpaceType->choice.ue_Specific)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ if(pdcchCfg == NULLP)
+ searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
+ else
+ searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
+ }
+ return ROK;
+}/* End BuildSearchSpcToAddModList */
+
+/*******************************************************************
+ *
+ * @brief Builds BWP DL dedicated PDCCH config
+ *
+ * @details
+ *
+ * Function : BuildBWPDlDedPdcchCfg
+ *
+ * Functionality: Builds BWP DL dedicated PDCCH config
+ *
+ * @params[in] struct PDCCH_Config *pdcchCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
+{
+ pdcchCfg->controlResourceSetToAddModList = NULLP;
+ DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
+ if(!pdcchCfg->controlResourceSetToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ return RFAILED;
+ }
+
+ if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed in BuildControlRSetToAddModList()");
+ return RFAILED;
+ }
+
+ pdcchCfg->controlResourceSetToReleaseList = NULLP;
+
+ pdcchCfg->searchSpacesToAddModList = NULLP;
+ DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
+ if(!pdcchCfg->searchSpacesToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ return RFAILED;
+ }
+
+ if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed in BuildSearchSpcToAddModList()");
+ return RFAILED;
+ }
+
+ pdcchCfg->searchSpacesToReleaseList = NULLP;
+ pdcchCfg->downlinkPreemption = NULLP;
+ pdcchCfg->tpc_PUSCH = NULLP;
+ pdcchCfg->tpc_PUCCH = NULLP;
+ pdcchCfg->tpc_SRS = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ * @brief Builds DMRS DL PDSCH Mapping type A
+ *
+ * @details
+ *
+ * Function : BuildDMRSDLPdschMapTypeA
+ *
+ * Functionality: Builds DMRS DL PDSCH Mapping type A
+ *
+ * @params[in]
+ * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
+{
+ dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
+ dmrsDlCfg->choice.setup = NULLP;
+ DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
+ if(!dmrsDlCfg->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
+ return RFAILED;
+ }
+
+ dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
+ dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
+ DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
+ if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
+ return RFAILED;
+ }
+ if(pdschCfg == NULLP)
+ *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
+ else
+ *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
+
+ dmrsDlCfg->choice.setup->maxLength = NULLP;
+ dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
+ dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
+ dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds TCI states to add/modify list
+ *
+ * @details
+ *
+ * Function : BuildTCIStatesToAddModList
+ *
+ * Functionality:Builds TCI states to add/modify list
+ *
+ * @params[in]
+ * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
+{
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds PDSCH time domain allocation list
+ *
+ * @details
+ *
+ * Function : BuildPdschTimeDomAllocList
+ *
+ * Functionality: Builds PDSCH time domain allocation list
+ *
+ * @params[in]
+ * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
+{
+ uint8_t idx;
+ uint8_t elementCnt;
+ struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
+
+ timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
+
+ timeDomAllocList->choice.setup = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
+ if(!timeDomAllocList->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+
+if(pdschCfg == NULLP)
+ elementCnt = 2;
+else
+elementCnt = pdschCfg->numTimeDomRsrcAlloc;
+ timeDomAllocList->choice.setup->list.count = elementCnt;
+ timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
+
+ timeDomAllocList->choice.setup->list.array = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
+ if(!timeDomAllocList->choice.setup->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ timeDomAllocList->choice.setup->list.array[idx] = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
+ sizeof(struct PDSCH_TimeDomainResourceAllocation));
+ if(!timeDomAllocList->choice.setup->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ }
+
+ if(pdschCfg == NULLP)
+ {
+ idx = 0;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ DU_ALLOC(timeDomAlloc->k0, sizeof(long));
+ if(!timeDomAlloc->k0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k0) = 0;
+ timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = \
+ calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
+
+ idx++;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ DU_ALLOC(timeDomAlloc->k0, sizeof(long));
+ if(!timeDomAlloc->k0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k0) = 1;
+ timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
+ }
+ else
+ {
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ if(pdschCfg->timeDomRsrcAllociList[idx].k0)
+ {
+ DU_ALLOC(timeDomAlloc->k0, sizeof(long));
+ if(!timeDomAlloc->k0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
+ }
+ timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
+ timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
+ }
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds PDSCH PRB Bundling type
+ *
+ * @details
+ *
+ * Function : BuildPdschPrbBundlingType
+ *
+ * Functionality: Builds PDSCH PRB Bundling type
+ *
+ * @params[in]
+ * struct PDSCH_Config__prb_BundlingType *prbBndlType
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
+{
+ if(pdschCfg == NULLP)
+ prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
+ else
+ prbBndlType->present = pdschCfg->bundlingType;
+
+ prbBndlType->choice.staticBundling = NULLP;
+ DU_ALLOC(prbBndlType->choice.staticBundling, \
+ sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
+ if(!prbBndlType->choice.staticBundling)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
+ return RFAILED;
+ }
+ prbBndlType->choice.staticBundling->bundleSize = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds BWP DL dedicated PDSCH config
+ *
+ * @details
+ *
+ * Function : BuildBWPDlDedPdschCfg
+ *
+ * Functionality: Builds BWP DL dedicated PDSCH config
+ *
+ * @params[in] struct PDSCH_Config *pdschCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
+{
+ pdschCfg->dataScramblingIdentityPDSCH = NULLP;
+
+ pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
+ DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
+ if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ return RFAILED;
+ }
+
+ if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
+ {
+ return RFAILED;
+ }
+
+ pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
+ pdschCfg->tci_StatesToAddModList = NULLP;
+ pdschCfg->tci_StatesToReleaseList = NULLP;
+ pdschCfg->vrb_ToPRB_Interleaver = NULLP;
+#if 0
+ DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
+ if(!pdschCfg->tci_StatesToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ return RFAILED;
+ }
+ if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
+ {
+ return RFAILED;
+ }
+#endif
+
+if(pdschCfgDb == NULLP)
+ pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
+else
+pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
+
+ pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
+ DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
+ if(!pdschCfg->pdsch_TimeDomainAllocationList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ return RFAILED;
+ }
+ if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
+ {
+ return RFAILED;
+ }
+
+ pdschCfg->pdsch_AggregationFactor = NULLP;
+ pdschCfg->rateMatchPatternToAddModList = NULLP;
+ pdschCfg->rateMatchPatternToReleaseList = NULLP;
+ pdschCfg->rateMatchPatternGroup1 = NULLP;
+ pdschCfg->rateMatchPatternGroup2 = NULLP;
+ if(pdschCfgDb == NULLP)
+ pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
+ else
+ pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
+ pdschCfg->mcs_Table = NULLP;
+
+ pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
+ DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
+ if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ return RFAILED;
+ }
+ if(pdschCfgDb == NULLP)
+ *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
+ else
+ *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
+
+ if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
+ {
+ return RFAILED;
+ }
+
+ pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
+ pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
+ pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
+ pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
+ pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
+ pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
+ pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds intitial DL BWP
+ * @details
+ *
+ * Function : BuildInitialDlBWP
+ *
+ * Functionality: Builds intitial DL BWP in spCellCfgDed
+ *
+ * @params[in] BWP_DownlinkDedicated_t *dlBwp
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
+{
+ PdcchConfig *pdcchCfg = NULLP;
+ PdschConfig *pdschCfg = NULLP;
+
+ if(initiDlBwp)
+ {
+ if(initiDlBwp->pdcchPresent)
+ pdcchCfg = &initiDlBwp->pdcchCfg;
+ if(initiDlBwp->pdschPresent)
+ pdschCfg = &initiDlBwp->pdschCfg;
+ }
+
+ dlBwp->pdcch_Config = NULLP;
+ DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
+ if(!dlBwp->pdcch_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ return RFAILED;
+ }
+ dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
+
+ dlBwp->pdcch_Config->choice.setup = NULLP;
+ DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
+ if(!dlBwp->pdcch_Config->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ return RFAILED;
+ }
+ if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
+
+ dlBwp->pdsch_Config = NULLP;
+ DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
+ if(!dlBwp->pdsch_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ return RFAILED;
+ }
+ dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
+
+ dlBwp->pdsch_Config->choice.setup = NULLP;
+ DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
+ if(!dlBwp->pdsch_Config->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failure in BuildInitialDlBWP");
+ return RFAILED;
+ }
+
+ if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
+
+ dlBwp->sps_Config = NULLP;
+ dlBwp->radioLinkMonitoringConfig = NULLP;
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds DMRS UL Pusch Mapping type A
+ *
+ * @details
+ *
+ * Function : BuildDMRSULPuschMapTypeA
+ *
+ * Functionality: Builds DMRS UL Pusch Mapping type A
+ *
+ * @params[in]
+ * struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
+{
+ dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
+ dmrsUlCfg->choice.setup= NULLP;
+ DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
+ if(!dmrsUlCfg->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ return RFAILED;
+ }
+
+ dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
+ dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
+ DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
+ if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ return RFAILED;
+ }
+ if(ulDmrsCfgDb == NULLP)
+ *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
+ else
+ *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
+
+ dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
+ dmrsUlCfg->choice.setup->maxLength = NULLP;
+ dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
+ DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
+ if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ return RFAILED;
+ }
+
+ dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
+ DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
+ sizeof(long));
+ if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ return RFAILED;
+ }
+ if(ulDmrsCfgDb == NULLP)
+ *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
+ else
+ *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
+
+ dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
+ dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Build PUSCH time domain allocation list
+ *
+ * @details
+ *
+ * Function : BuildPuschTimeDomAllocList
+ *
+ * Functionality: Build PUSCH time domain allocation list
+ *
+ * @params[in]
+ * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
+{
+ uint8_t idx;
+ uint8_t elementCnt;
+ PUSCH_TimeDomainResourceAllocation_t *timeDomAlloc;
+
+ timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
+ timeDomAllocList->choice.setup = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
+ if(!timeDomAllocList->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+
+ if(puschCfgDb == NULLP)
+ elementCnt = 2;
+ else
+ elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
+
+ timeDomAllocList->choice.setup->list.count = elementCnt;
+ timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
+ timeDomAllocList->choice.setup->list.array = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
+ if(!timeDomAllocList->choice.setup->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ timeDomAllocList->choice.setup->list.array[idx] = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
+ if(!timeDomAllocList->choice.setup->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ DU_ALLOC(timeDomAlloc->k2, sizeof(long));
+ if(!timeDomAlloc->k2)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+ if(puschCfgDb == NULLP)
+ {
+ if(idx == 0)
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
+ else if(idx == 1)
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
+
+ timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
+ }
+ else
+ {
+ *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
+ timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
+ timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
+ }
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds BWP UL dedicated PUSCH Config
+ *
+ * @details
+ *
+ * Function : BuildBWPUlDedPuschCfg
+ *
+ * Functionality:
+ * Builds BWP UL dedicated PUSCH Config
+ *
+ * @params[in] : PUSCH_Config_t *puschCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
+{
+ DmrsUlCfg *ulDmrsCfg = NULLP;
+
+ if(puschCfgDb)
+ ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
+
+ puschCfg->dataScramblingIdentityPUSCH = NULLP;
+ DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
+ if(!puschCfg->dataScramblingIdentityPUSCH)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ return RFAILED;
+ }
+ if(puschCfgDb == NULLP)
+ *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
+ else
+ *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
+
+ puschCfg->txConfig = NULLP;
+ puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
+ DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
+ if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ return RFAILED;
+ }
+
+ if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
+ {
+ return RFAILED;
+ }
+
+ puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
+ puschCfg->pusch_PowerControl = NULLP;
+ puschCfg->frequencyHopping = NULLP;
+ puschCfg->frequencyHoppingOffsetLists = NULLP;
+
+ if(puschCfgDb == NULLP)
+ puschCfg->resourceAllocation = RES_ALLOC_TYPE;
+ else
+ puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
+
+ puschCfg->pusch_TimeDomainAllocationList = NULLP;
+ DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
+ if(!puschCfg->pusch_TimeDomainAllocationList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ return RFAILED;
+ }
+
+ if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
+ {
+ return RFAILED;
+ }
+
+ puschCfg->pusch_AggregationFactor = NULLP;
+ puschCfg->mcs_Table = NULLP;
+ puschCfg->mcs_TableTransformPrecoder = NULLP;
+ puschCfg->transformPrecoder = NULLP;
+ DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
+ if(!puschCfg->transformPrecoder)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ return RFAILED;
+ }
+ if(puschCfgDb == NULLP)
+ *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
+ else
+ *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
+
+ puschCfg->codebookSubset = NULLP;
+ puschCfg->maxRank = NULLP;
+ puschCfg->rbg_Size = NULLP;
+ puschCfg->uci_OnPUSCH = NULLP;
+ puschCfg->tp_pi2BPSK = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds PUCCH resource set add/modify list
+ *
+ * @details
+ *
+ * Function : BuildPucchRsrcSetAddModList
+ *
+ * Functionality:
+ * Builds PUCCH resource set add/modify list
+ *
+ * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
+ * struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
+ struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
+{
+ uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
+ PUCCH_ResourceSet_t *rsrcSet = NULLP;
+
+ if(rsrcSetCfgDb == NULLP)
+ elementCnt = 1;
+ else
+ elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
+
+ resourceSetToAddModList->list.count = elementCnt;
+ resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
+ DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
+ if(resourceSetToAddModList->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ return RFAILED;
+ }
+ for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
+ {
+ DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
+ if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ return RFAILED;
+ }
+ }
+
+ for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
+ {
+ rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
+
+ /* Resource set Id */
+ if(rsrcSetCfgDb == NULLP)
+ rsrcSet->pucch_ResourceSetId = 1;
+ else
+ rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
+
+ /* Resource list of a resource set */
+ if(rsrcSetCfgDb == NULLP)
+ elementCnt = 1;
+ else
+ elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
+ rsrcSet->resourceList.list.count = elementCnt;
+ rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
+ DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
+ if(rsrcSet->resourceList.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ return RFAILED;
+ }
+
+ for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
+ {
+ DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
+ if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ return RFAILED;
+ }
+ }
+ for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
+ {
+ if(rsrcSetCfgDb == NULLP)
+ *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
+ else
+ *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
+ }
+
+ /* Max payload size (minus 1) in a Resource set */
+ rsrcSet->maxPayloadMinus1 = NULLP;
+ if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
+ {
+ DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
+ if(rsrcSet->maxPayloadMinus1 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
+ return RFAILED;
+ }
+ *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds PUCCH resource add/modify list
+ *
+ * @details
+ *
+ * Function : BuildPucchRsrcAdddModList
+ *
+ * Functionality:
+ * Builds PUCCH resource add/modify list
+ *
+ * @params[in] : PucchResrcCfg *rsrcSetCfgDb
+ * struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList *resourceToAddModList)
+{
+ uint8_t elementCnt = 0, rsrcIdx = 0;
+ PUCCH_Resource_t *rsrc = NULLP;
+
+ if(rsrcCfgDb == NULLP)
+ elementCnt = 1;
+ else
+ elementCnt = rsrcCfgDb->resrcToAddModListCount;
+ resourceToAddModList->list.count = elementCnt;
+ resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
+ DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
+ if(resourceToAddModList->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
+ {
+ DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
+ if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ }
+
+ for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
+ {
+ rsrc = resourceToAddModList->list.array[rsrcIdx];
+
+ if(rsrcCfgDb == NULLP)
+ {
+ rsrc->pucch_ResourceId = 1;
+ rsrc->startingPRB = 0;
+ rsrc->format.present = PUCCH_Resource__format_PR_format1;
+ DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
+ if(rsrc->format.choice.format1 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ rsrc->format.choice.format1->initialCyclicShift = 0;
+ rsrc->format.choice.format1->nrofSymbols = 4;
+ rsrc->format.choice.format1->startingSymbolIndex = 0;
+ rsrc->format.choice.format1->timeDomainOCC = 0;
+ }
+ else
+ {
+ rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
+ rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
+ if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
+ {
+ DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
+ if(rsrc->intraSlotFrequencyHopping == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
+ }
+ else
+ rsrc->intraSlotFrequencyHopping = NULLP;
+
+ if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
+ {
+ DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
+ if(rsrc->secondHopPRB == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
+ }
+ else
+ rsrc->secondHopPRB = NULLP;
+ rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
+
+ switch(rsrc->format.present)
+ {
+ case PUCCH_Resource__format_PR_NOTHING:
+ break;
+ case PUCCH_Resource__format_PR_format0:
+ {
+ DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
+ if(rsrc->format.choice.format0 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
+ rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
+ rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
+ break;
+ }
+
+ case PUCCH_Resource__format_PR_format1:
+ {
+ DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
+ if(rsrc->format.choice.format1 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
+ rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
+ rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
+ rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
+ break;
+ }
+
+ case PUCCH_Resource__format_PR_format2:
+ {
+ DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
+ if(rsrc->format.choice.format2 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
+ rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
+ rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
+ break;
+ }
+
+ case PUCCH_Resource__format_PR_format3:
+ {
+ DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
+ if(rsrc->format.choice.format3 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
+ rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
+ rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
+ break;
+ }
+
+ case PUCCH_Resource__format_PR_format4:
+ {
+ DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
+ if(rsrc->format.choice.format4 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
+ return RFAILED;
+ }
+ rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
+ rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
+ rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
+ rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
+ break;
+ }
+ }
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds PUCCH format config
+ *
+ * @details
+ *
+ * Function : BuildPucchFormat
+ *
+ * Functionality: Builds PUCCH format config
+ *
+ * @params[in] : PucchFormatCfg *formatDb
+ * PUCCH_FormatConfig_t *format
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
+{
+ /* Inter Slot Fequency hopping */
+ format->interslotFrequencyHopping = NULLP;
+ if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
+ {
+ DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
+ if(format->interslotFrequencyHopping)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ return RFAILED;
+ }
+ *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
+ }
+
+ /* Additional DMRS */
+ format->additionalDMRS = NULLP;
+ if((formatDb != NULLP) && (formatDb->addDmrs == true))
+ {
+ DU_ALLOC(format->additionalDMRS, sizeof(long));
+ if(format->additionalDMRS)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ return RFAILED;
+ }
+ *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
+ }
+
+ /* Maximum code rate */
+ format->maxCodeRate = NULLP;
+ if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
+ {
+ DU_ALLOC(format->maxCodeRate, sizeof(long));
+ if(format->maxCodeRate)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ return RFAILED;
+ }
+ *(format->maxCodeRate) = formatDb->maxCodeRate;
+ }
+
+ /* Number of slots */
+ format->nrofSlots = NULLP;
+ if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
+ {
+ DU_ALLOC(format->nrofSlots, sizeof(long));
+ if(format->nrofSlots == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ return RFAILED;
+ }
+ if(formatDb == NULLP)
+ *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
+ else
+ *(format->nrofSlots) = formatDb->numSlots;
+ }
+
+ /* Pi2BPSK*/
+ format->pi2BPSK = NULLP;
+ if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
+ {
+ DU_ALLOC(format->pi2BPSK, sizeof(long));
+ if(format->pi2BPSK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ return RFAILED;
+ }
+ *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
+ }
+
+ /* Simultaneous HARQ ACK and CSI */
+ format->simultaneousHARQ_ACK_CSI = NULLP;
+ if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
+ {
+ DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
+ if(format->simultaneousHARQ_ACK_CSI)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPucchFormat");
+ return RFAILED;
+ }
+ *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
+ }
+
+ return ROK;
+}
+
+
+/*******************************************************************
+ *
+ * @brief Builds PUCCH scheduling request list
+ *
+ * @details
+ *
+ * Function : BuildPucchSchReqAddModList
+ *
+ * Functionality:
+ * Builds PUCCH scheduling request list
+ *
+ * @params[in] : PucchSchedReqCfg *schReqDb
+ * struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
+ struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
+{
+ uint8_t elementCnt = 0, schReqIdx = 0;
+ SchedulingRequestResourceConfig_t *schReqRsrc;
+
+ elementCnt = schReqDb->schedAddModListCount;
+ schReqRsrcToAddModList->list.count = elementCnt;
+ schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
+
+ schReqRsrcToAddModList->list.array = NULLP;
+ DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
+ if(schReqRsrcToAddModList->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
+ return RFAILED;
+ }
+
+ for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
+ {
+ DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
+ if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
+ return RFAILED;
+ }
+ }
+
+ for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
+ {
+ schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
+ schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
+ schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
+
+ if(schReqDb->schedAddModList[schReqIdx].periodicity)
+ {
+ schReqRsrc->periodicityAndOffset = NULLP;
+ DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
+ if(schReqRsrc->periodicityAndOffset == NULLP)
+ {
+ DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
+ return RFAILED;
+ }
+
+ schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
+ switch(schReqRsrc->periodicityAndOffset->present)
+ {
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
+ schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
+ schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
+ schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
+ schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
+ schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
+ schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
+ schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
+ schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
+ schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
+ schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
+ schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
+ schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
+ schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
+ schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
+ schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
+ break;
+ }
+ }
+
+ if(schReqDb->schedAddModList[schReqIdx].resrc)
+ {
+ schReqRsrc->resource = NULLP;
+ DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
+ if(schReqRsrc->resource == NULLP)
+ {
+ DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
+ return RFAILED;
+ }
+ *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
+
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds PUCCH multi csi resource list
+ *
+ * @details
+ *
+ * Function : BuildPucchMultiCsiRsrcList
+ *
+ * Functionality:
+ * Builds PUCCH multi csi resource list
+ *
+ * @params[in] : PucchMultiCsiCfg *multiCsiDb
+ * struct PUCCH_Config__multi_CSI_PUCCH_ResourceList *multiCsiRsrcList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList *multiCsiRsrcList)
+{
+ uint8_t elementCnt = 0, rsrcIdx = 0;
+
+ elementCnt = multiCsiDb->multiCsiResrcListCount;
+ multiCsiRsrcList->list.count = elementCnt;
+ multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
+ multiCsiRsrcList->list.array = NULLP;
+ DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
+ if(multiCsiRsrcList->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
+ return RFAILED;
+ }
+
+ for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
+ {
+ DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
+ if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
+ return RFAILED;
+ }
+ }
+
+ for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
+ {
+ *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds DL data -to- Ul Ack list
+ *
+ * @details
+ *
+ * Function : BuildDlDataToUlAckList
+ *
+ * Functionality: Builds DL data -to- Ul Ack list
+ *
+ * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
+ * struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
+{
+ uint8_t elementCnt = 0, arrIdx = 0;
+
+ if(dlDataToUlAckDb == NULLP)
+ elementCnt = 2;
+ else
+ elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
+
+ dlDataToUlACKList->list.count = elementCnt;
+ dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
+ DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
+ if(dlDataToUlACKList->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDlDataToUlAckList");
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx < dlDataToUlACKList->list.count; arrIdx++)
+ {
+ DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
+ if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDlDataToUlAckList");
+ return RFAILED;
+ }
+ }
+
+ if(dlDataToUlAckDb == NULLP)
+ {
+ arrIdx = 0;
+ *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
+ *(dlDataToUlACKList->list.array[arrIdx]) = 2;
+ }
+ else
+ {
+ for(arrIdx = 0; arrIdx < dlDataToUlACKList->list.count; arrIdx++)
+ {
+ *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds BWP UL dedicated PUCCH Config
+ *
+ * @details
+ *
+ * Function : BuildBWPUlDedPucchCfg
+ *
+ * Functionality:
+ * Builds BWP UL dedicated PUCCH Config
+ *
+ * @params[in] : PUCCH_Config_t *pucchCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
+{
+ PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
+ PucchResrcCfg *rsrcCfgDb = NULLP;
+ PucchFormatCfg *format1Db = NULLP;
+ PucchFormatCfg *format2Db = NULLP;
+ PucchFormatCfg *format3Db = NULLP;
+ PucchFormatCfg *format4Db = NULLP;
+ PucchSchedReqCfg *schReqDb = NULLP;
+ PucchMultiCsiCfg *multiCsiDb = NULLP;
+ PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
+
+ if(pucchCfgDb)
+ {
+ rsrcSetCfgDb = pucchCfgDb->resrcSet;
+ rsrcCfgDb = pucchCfgDb->resrc;
+ format1Db = pucchCfgDb->format1;
+ format2Db = pucchCfgDb->format2;
+ format3Db = pucchCfgDb->format3;
+ format4Db = pucchCfgDb->format4;
+ schReqDb = pucchCfgDb->schedReq;
+ multiCsiDb = pucchCfgDb->multiCsiCfg;
+ dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
+ }
+
+ /* RESOURCE SET */
+ DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
+ if(pucchCfg->resourceSetToAddModList == NULL)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ /* PUCCH RESOURCE */
+ DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
+ if(pucchCfg->resourceToAddModList == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ /* PUCCH Format 1 */
+ DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
+ if(pucchCfg->format1 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
+ DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
+ if(pucchCfg->format1->choice.setup == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ /* PUCCH Format 2 */
+ if(format2Db)
+ {
+ DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
+ if(pucchCfg->format2 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
+ DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
+ if(pucchCfg->format2->choice.setup == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+ }
+
+ /* PUCCH Format 3 */
+ if(format3Db)
+ {
+ DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
+ if(pucchCfg->format3 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
+ DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
+ if(pucchCfg->format3->choice.setup == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+ }
+
+ /* PUCCH Format 4 */
+ if(format4Db)
+ {
+ DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
+ if(pucchCfg->format4 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
+ DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
+ if(pucchCfg->format4->choice.setup == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+ }
+
+ /* Scheduling Request */
+ if(schReqDb && (schReqDb->schedAddModListCount != 0))
+ {
+ pucchCfg->schedulingRequestResourceToAddModList = NULLP;
+ DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
+ if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+ }
+
+ /* Multi CSI */
+ if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
+ {
+ pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP;
+ DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
+ if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+ }
+
+ /* DL DATA TO UL ACK */
+ DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
+ if(pucchCfg->dl_DataToUL_ACK == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ /* TODO : spatial relation info add/mod list and power control*/
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills SRS resource to add/modify list
+ *
+ * @details
+ *
+ * Function : BuildSrsRsrcAddModList
+ *
+ * Functionality: Fills SRS resource to add/modify list
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
+{
+ uint8_t elementCnt;
+ uint8_t rsrcIdx;
+
+ elementCnt = 1;
+ resourceList->list.count = elementCnt;
+ resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
+ resourceList->list.array = NULLP;
+ DU_ALLOC(resourceList->list.array, resourceList->list.size);
+ if(!resourceList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
+ return RFAILED;
+ }
+
+ for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
+ {
+ DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
+ if(!resourceList->list.array[rsrcIdx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
+ return RFAILED;
+ }
+ }
+
+ rsrcIdx = 0;
+ resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
+ resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
+ resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
+
+ resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
+ DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
+ sizeof(struct SRS_Resource__transmissionComb__n2));
+ if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
+ return RFAILED;
+ }
+ resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
+ = SRS_COMB_OFFSET_N2;
+ resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
+ = SRS_CYCLIC_SHIFT_N2;
+
+ resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
+ PUSCH_START_SYMBOL;
+ resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols = \
+ SRS_Resource__resourceMapping__nrofSymbols_n1;
+ resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
+ SRS_Resource__resourceMapping__repetitionFactor_n1;
+
+ resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
+ resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
+ resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
+ resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
+ resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
+ resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
+ SRS_Resource__groupOrSequenceHopping_neither;
+
+ /* Setting resource type to aperiodic for intergration purposes */
+ resourceList->list.array[rsrcIdx]->resourceType.present = \
+ SRS_Resource__resourceType_PR_aperiodic;
+ resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
+ DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
+ sizeof(struct SRS_Resource__resourceType__aperiodic));
+ if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
+ return RFAILED;
+ }
+
+ resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Build SRS resource set Add/mod list
+ *
+ * @details
+ *
+ * Function : BuildSrsRsrcSetAddModList