+ ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
+ if(ueSetReq->protocolIEs.list.array != NULLP)
+ {
+ for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
+ {
+ if(ueSetReq->protocolIEs.list.array[idx])
+ {
+ switch(ueSetReq->protocolIEs.list.array[idx]->id)
+ {
+ case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
+ break;
+ case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
+ break;
+ case ProtocolIE_ID_id_SpCell_ID:
+ FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
+ break;
+ case ProtocolIE_ID_id_ServCellIndex:
+ break;
+ case ProtocolIE_ID_id_SpCellULConfigured:
+ break;
+ case ProtocolIE_ID_id_CUtoDURRCInformation:
+ FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
+ break;
+ case ProtocolIE_ID_id_SCell_ToBeSetup_List:
+ FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
+ break;
+ case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
+ FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
+ break;
+ case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
+ FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
+ break;
+ case ProtocolIE_ID_id_RRCContainer:
+ if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
+ {
+ CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
+ }
+ break;
+ case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
+ CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
+ ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
+ break;
+ default:
+ DU_LOG("\nERROR --> F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
+ break;
+ }
+ }
+ /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
+ }
+ for(ieId=0; ieId<idx; ieId++)
+ {
+ if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
+ {
+ CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
+ }
+ }
+ CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
+ }
+ CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
+ }
+ CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
+ }
+}
+
+/**Filling cell group info **/
+/*******************************************************************
+ *
+ * @brief Build Control resource set to add/modify list
+ *
+ * @details
+ *
+ * Function : BuildControlRSetToAddModList
+ *
+ * Functionality: Build Control resource set to add/modify list
+ *
+ * @params[in]
+ * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+ uint8_t BuildControlRSetToAddModList
+(
+ struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
+ )
+{
+ uint8_t idx;
+ uint8_t elementCnt;
+ uint8_t numBytes, bitsUnused;
+ struct ControlResourceSet *controlRSet;
+ uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
+ uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
+
+ elementCnt = 1;
+ controlRSetList->list.count = elementCnt;
+ controlRSetList->list.size = \
+ elementCnt * sizeof(struct ControlResourceSet *);
+
+ controlRSetList->list.array = NULLP;
+ CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
+ if(!controlRSetList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ controlRSetList->list.array[idx] = NULLP;
+ CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
+ if(!controlRSetList->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ }
+
+ idx=0;
+ controlRSet = controlRSetList->list.array[idx];
+ controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
+
+ /* Values harcoded according to our design:
+ * size 6 bytes
+ * 3 LSBs unsued
+ * Bit string stored ff0000000000
+ */
+ numBytes = 6;
+ bitsUnused = 3;
+ controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
+ controlRSet->frequencyDomainResources.buf = NULLP;
+ CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
+ controlRSet->frequencyDomainResources.size);
+ if(!controlRSet->frequencyDomainResources.buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+
+ memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
+ coreset0EndPrb = CORESET0_END_PRB;
+ coreset1StartPrb = coreset0EndPrb + 6;
+ coreset1NumPrb = CORESET1_NUM_PRB;
+ /* calculate the PRBs */
+ fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
+ memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
+ controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
+
+ controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
+ controlRSet->cce_REG_MappingType.present = \
+ ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
+
+ controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
+ controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
+ controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
+ controlRSet->tci_PresentInDCI = NULLP;
+#if 0
+ uint8_t tciStateIdx;
+
+ CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
+ sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
+ if(!controlRset->tci_StatesPDCCH_ToAddList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
+ controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
+ CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
+ controlRset->tci_StatesPDCCH_ToAddList->list.size)
+ if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+
+ for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
+ {
+ CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
+ if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ }
+
+ tciStateIdx = 0;
+ /* TODO */
+ *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
+
+ CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
+ if(!controlRset->tci_PresentInDCI)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ /* TODO */
+ *(controlRset->tci_PresentInDCI);
+#endif
+
+ controlRSet->pdcch_DMRS_ScramblingID = NULLP;
+ CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
+ if(!controlRSet->pdcch_DMRS_ScramblingID)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
+
+ return ROK;
+} /* End BuildControlRSetToAddModList */
+
+/*******************************************************************
+ *
+ * @brief Build search space to add/modify list
+ *
+ * @details
+ *
+ * Function : BuildSearchSpcToAddModList
+ *
+ * Functionality: Build search space to add/modify list
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+ uint8_t BuildSearchSpcToAddModList
+(
+ struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
+ )
+{
+ uint8_t idx;
+ uint8_t numBytes;
+ uint8_t byteIdx;
+ uint8_t bitsUnused;
+ uint8_t elementCnt;
+ struct SearchSpace *searchSpc;
+
+ elementCnt = 1;
+ searchSpcList->list.count = elementCnt;
+ searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
+
+ searchSpcList->list.array = NULLP;
+ CU_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;
+ CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
+ if(!searchSpcList->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ searchSpc = searchSpcList->list.array[idx];
+
+ searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
+
+ searchSpc->controlResourceSetId = NULLP;
+ CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
+ if(!searchSpc->controlResourceSetId)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
+
+ searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
+ CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
+ sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
+ if(!searchSpc->monitoringSlotPeriodicityAndOffset)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ searchSpc->monitoringSlotPeriodicityAndOffset->present = \
+ SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
+
+ searchSpc->duration = NULLP;
+ searchSpc->monitoringSymbolsWithinSlot = NULLP;
+ CU_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;
+ CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
+ searchSpc->monitoringSymbolsWithinSlot->size);
+ if(!searchSpc->monitoringSymbolsWithinSlot->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+
+ byteIdx = 0;
+ searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
+ PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
+ searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
+ searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
+
+ searchSpc->nrofCandidates = NULLP;
+ CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
+ if(!searchSpc->nrofCandidates)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+
+ 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;
+
+ searchSpc->searchSpaceType = NULLP;
+ CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
+ if(!searchSpc->searchSpaceType)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+
+ searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
+
+ searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
+ CU_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;
+ }
+ searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
+ PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
+
+ 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(struct PDCCH_Config *pdcchCfg)
+{
+ pdcchCfg->controlResourceSetToAddModList = NULLP;
+ CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
+ sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
+ if(!pdcchCfg->controlResourceSetToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ return RFAILED;
+ }
+
+ if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
+ {
+ return RFAILED;
+ }
+
+ pdcchCfg->controlResourceSetToReleaseList = NULLP;
+
+ pdcchCfg->searchSpacesToAddModList = NULLP;
+ CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
+ sizeof(struct PDCCH_Config__searchSpacesToAddModList));
+ if(!pdcchCfg->searchSpacesToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ return RFAILED;
+ }
+
+ if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
+ {
+ 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
+(
+ struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
+ )
+{
+ dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
+ dmrsDlCfg->choice.setup = NULLP;
+ CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
+ if(!dmrsDlCfg->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ return RFAILED;
+ }
+
+ dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
+ dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
+ CU_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;
+ }
+ *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
+
+ 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
+(
+ 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;
+ CU_ALLOC(timeDomAllocList->choice.setup, \
+ sizeof(struct PDSCH_TimeDomainResourceAllocationList));
+ if(!timeDomAllocList->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+
+ elementCnt = 2;
+ timeDomAllocList->choice.setup->list.count = elementCnt;
+ timeDomAllocList->choice.setup->list.size = \
+ elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
+
+ timeDomAllocList->choice.setup->list.array = NULLP;
+ CU_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;
+ CU_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;
+ }
+ }
+
+ idx = 0;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_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 = 66;
+
+ idx++;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_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 = 66;
+
+ 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
+(
+ struct PDSCH_Config__prb_BundlingType *prbBndlType
+ )
+{
+ prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
+
+ prbBndlType->choice.staticBundling = NULLP;
+ CU_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(struct PDSCH_Config *pdschCfg)
+{
+ pdschCfg->dataScramblingIdentityPDSCH = NULLP;
+
+ pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
+ CU_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(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
+ CU_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
+
+ pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
+
+ pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
+ CU_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(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
+ {
+ return RFAILED;
+ }
+ pdschCfg->pdsch_AggregationFactor = NULLP;
+ pdschCfg->rateMatchPatternToAddModList = NULLP;
+ pdschCfg->rateMatchPatternToReleaseList = NULLP;
+ pdschCfg->rateMatchPatternGroup1 = NULLP;
+ pdschCfg->rateMatchPatternGroup2 = NULLP;
+ pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
+ pdschCfg->mcs_Table = NULLP;
+
+ pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
+ CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
+ if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ return RFAILED;
+ }
+ *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
+
+ if(BuildPdschPrbBundlingType(&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(BWP_DownlinkDedicated_t *dlBwp)
+{
+ dlBwp->pdcch_Config = NULLP;
+ CU_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;
+ CU_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(dlBwp->pdcch_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
+
+ dlBwp->pdsch_Config = NULLP;
+ CU_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;
+ CU_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(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
+(
+ struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
+ )
+{
+ dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
+ dmrsUlCfg->choice.setup= NULLP;
+ CU_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;
+ CU_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;
+ }
+ *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
+
+ dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
+ dmrsUlCfg->choice.setup->maxLength = NULLP;
+ dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
+ CU_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;
+ CU_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;
+ }
+ *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
+
+ 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
+(
+ 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;
+ CU_ALLOC(timeDomAllocList->choice.setup, \
+ sizeof(struct PUSCH_TimeDomainResourceAllocationList));
+ if(!timeDomAllocList->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+
+ elementCnt = 2;
+ timeDomAllocList->choice.setup->list.count = elementCnt;
+ timeDomAllocList->choice.setup->list.size = \
+ elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
+ timeDomAllocList->choice.setup->list.array = NULLP;
+ CU_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;
+ CU_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;
+ }
+ }
+
+ idx = 0;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_ALLOC(timeDomAlloc->k2, sizeof(long));
+ if(!timeDomAlloc->k2)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
+ timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = 66;
+
+ idx++;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_ALLOC(timeDomAlloc->k2, sizeof(long));
+ if(!timeDomAlloc->k2)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
+ timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = 66;
+
+ 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(PUSCH_Config_t *puschCfg)
+{
+ puschCfg->dataScramblingIdentityPUSCH = NULLP;
+ CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
+ if(!puschCfg->dataScramblingIdentityPUSCH)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ return RFAILED;
+ }
+ *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
+
+ puschCfg->txConfig = NULLP;
+ puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
+ CU_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(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
+ {
+ return RFAILED;
+ }
+
+ puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
+ puschCfg->pusch_PowerControl = NULLP;
+ puschCfg->frequencyHopping = NULLP;
+ puschCfg->frequencyHoppingOffsetLists = NULLP;
+ puschCfg->resourceAllocation = RES_ALLOC_TYPE;
+
+ puschCfg->pusch_TimeDomainAllocationList = NULLP;
+ CU_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(puschCfg->pusch_TimeDomainAllocationList) != ROK)
+ {
+ return RFAILED;
+ }
+
+ puschCfg->pusch_AggregationFactor = NULLP;
+ puschCfg->mcs_Table = NULLP;
+ puschCfg->mcs_TableTransformPrecoder = NULLP;
+ puschCfg->transformPrecoder = NULLP;
+ CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
+ if(!puschCfg->transformPrecoder)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
+ return RFAILED;
+ }
+ *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
+
+ puschCfg->codebookSubset = NULLP;
+ puschCfg->maxRank = NULLP;
+ puschCfg->rbg_Size = NULLP;
+ puschCfg->uci_OnPUSCH = NULLP;
+ puschCfg->tp_pi2BPSK = NULLP;
+
+ 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(PUCCH_Config_t *pucchCfg)
+{
+ uint8_t arrIdx, elementCnt;
+ uint8_t rsrcIdx, rsrcSetIdx;
+ PUCCH_ResourceSet_t *rsrcSet = NULLP;
+ PUCCH_Resource_t *rsrc = NULLP;
+
+ //RESOURCE SET
+ elementCnt = 1;
+ CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
+ pucchCfg->resourceSetToAddModList->list.count = elementCnt;
+ pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
+ CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
+ for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
+ {
+ CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
+ }
+ rsrcSetIdx = 0;
+ rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
+ rsrcSet->pucch_ResourceSetId = 1;
+ elementCnt = 1;
+ rsrcSet->resourceList.list.count = elementCnt;
+ rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
+ CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
+ for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
+ {
+ CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
+ }
+ rsrcIdx = 0;
+ *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
+
+ //RESOURCE
+ elementCnt = 1;
+ CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
+ pucchCfg->resourceToAddModList->list.count = elementCnt;
+ pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
+ CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
+ for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
+ {
+ CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
+ }
+ rsrcIdx = 0;
+ rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
+ rsrc->pucch_ResourceId = 1;
+ rsrc->startingPRB = 0;
+ rsrc->format.present = PUCCH_Resource__format_PR_format1;
+ CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
+ rsrc->format.choice.format1->initialCyclicShift = 0;
+ rsrc->format.choice.format1->nrofSymbols = 4;
+ rsrc->format.choice.format1->startingSymbolIndex = 0;
+ rsrc->format.choice.format1->timeDomainOCC = 0;
+
+ //PUCCH Format 1
+ CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
+ pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
+ CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
+ CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
+ *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
+
+ //DL DATA TO UL ACK
+ CU_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;
+ }
+
+ elementCnt = 2;
+ pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
+ pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
+ CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
+ if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx < pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
+ {
+ CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
+ if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+ }
+
+ arrIdx = 0;
+ *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
+ *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
+
+ 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;
+ CU_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++)
+ {
+ CU_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;
+ CU_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;
+ CU_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
+ *
+ * Functionality: Build SRS resource set Add/mod list
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+ uint8_t BuildSrsRsrcSetAddModList
+(
+ struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
+ )
+{
+ uint8_t elementCnt;
+ uint8_t rSetIdx;
+ uint8_t rsrcIdx;
+ struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
+
+ elementCnt = 1;
+ rsrcSetList->list.count = elementCnt;
+ rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
+ rsrcSetList->list.array = NULLP;
+ CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
+ if(!rsrcSetList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ return RFAILED;
+ }
+
+ for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
+ {
+ CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
+ if(!rsrcSetList->list.array[rSetIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ return RFAILED;
+ }
+ }
+
+ rSetIdx = 0;
+ rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
+
+ /* Fill Resource Id list in resource set */
+ rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
+ CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
+ sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
+ if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
+ rsrcIdList->list.count = elementCnt;
+ rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
+ rsrcIdList->list.array = NULLP;
+ CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
+ if(!rsrcIdList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ return RFAILED;
+ }
+
+ for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
+ {
+ CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
+ if(!rsrcIdList->list.array[rsrcIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ return RFAILED;
+ }
+ }
+
+ rsrcIdx = 0;
+ *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
+
+ /* Fill resource type */
+ rsrcSetList->list.array[rSetIdx]->resourceType.present = \
+ SRS_ResourceSet__resourceType_PR_aperiodic;
+
+ rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
+ CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
+ sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
+ if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ return RFAILED;
+ }
+ rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
+ = APERIODIC_SRS_RESRC_TRIGGER;
+
+ /* TODO : Fill values for below IEs as expected by Viavi */
+ rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
+ rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
+
+
+ rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
+ rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
+ rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
+ rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
+ rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds BWP UL dedicated SRS Config
+ *
+ * @details
+ *
+ * Function : BuildBWPUlDedSrsCfg
+ *
+ * Functionality: Builds BWP UL dedicated SRS Config
+ *
+ * @params[in] SRS Config
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
+{
+ srsCfg->srs_ResourceSetToReleaseList = NULLP;
+ srsCfg->srs_ResourceSetToAddModList = NULLP;
+ CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
+ sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
+ if(!srsCfg->srs_ResourceSetToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
+ return RFAILED;
+ }
+ if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
+ {
+ return RFAILED;
+ }
+
+ srsCfg->srs_ResourceToReleaseList = NULLP;
+
+ /* Resource to Add/Modify list */
+ srsCfg->srs_ResourceToAddModList = NULLP;
+ CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
+ sizeof(struct SRS_Config__srs_ResourceToAddModList));
+ if(!srsCfg->srs_ResourceToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
+ return RFAILED;
+ }
+
+ if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
+ {
+ return RFAILED;
+ }
+
+ srsCfg->tpc_Accumulation = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds inital UL BWP
+ *
+ * @details
+ *
+ * Function : BuildInitialUlBWP
+ *
+ * Functionality: Builds initial UL BWP
+ *
+ * @params[in] BWP_UplinkDedicated_t *ulBwp
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
+{
+ ulBwp->pucch_Config = NULLP;
+ ulBwp->pucch_Config = NULLP;
+ CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
+ if(!ulBwp->pucch_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
+ ulBwp->pucch_Config->choice.setup = NULLP;
+ CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
+ if(!ulBwp->pucch_Config->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
+
+ /* Fill BWP UL dedicated PUSCH config */
+ ulBwp->pusch_Config = NULLP;
+ CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
+ if(!ulBwp->pusch_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
+ ulBwp->pusch_Config->choice.setup = NULLP;
+ CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
+ if(!ulBwp->pusch_Config->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
+
+ ulBwp->configuredGrantConfig = NULLP;
+
+ /* Fill BPW UL dedicated SRS config */
+ ulBwp->srs_Config = NULLP;
+ CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
+ if(!ulBwp->srs_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
+ ulBwp->srs_Config->choice.setup = NULLP;
+ CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
+ if(!ulBwp->srs_Config->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
+
+ ulBwp->beamFailureRecoveryConfig = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds Pusch Serving cell Config
+ *
+ * @details
+ *
+ * Function : BuildPuschSrvCellCfg
+ *
+ * Functionality: Builds Pusch Serving cell Config
+ *
+ * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
+{
+ puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
+ puschCfg->choice.setup = NULLP;
+ CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
+ if(!puschCfg->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ return RFAILED;
+ }
+
+ puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
+ puschCfg->choice.setup->rateMatching = NULLP;
+ puschCfg->choice.setup->xOverhead = NULLP;
+ puschCfg->choice.setup->ext1 = NULLP;
+ CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
+ if(!puschCfg->choice.setup->ext1)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ return RFAILED;
+ }
+
+ puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
+ CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
+ if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ return RFAILED;
+ }
+ *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
+
+ puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
+ CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
+ if(!puschCfg->choice.setup->ext1->processingType2Enabled)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ return RFAILED;
+ }
+ *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds UL config
+ * @details
+ *
+ * Function : BuildUlCfg
+ *
+ * Functionality: Builds UL config in spCellCfgDed
+ *
+ * @params[in] UplinkConfig_t *ulCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
+{
+ ulCfg->initialUplinkBWP = NULLP;
+ CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
+ if(!ulCfg->initialUplinkBWP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
+ return RFAILED;
+ }
+
+ if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
+ {
+ return RFAILED;
+ }
+
+ ulCfg->uplinkBWP_ToReleaseList = NULLP;
+ ulCfg->uplinkBWP_ToAddModList = NULLP;
+ ulCfg->firstActiveUplinkBWP_Id = NULLP;
+ CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
+ if(!ulCfg->firstActiveUplinkBWP_Id)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
+ return RFAILED;
+ }
+ *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
+
+ ulCfg->pusch_ServingCellConfig = NULLP;
+ CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
+ sizeof(struct UplinkConfig__pusch_ServingCellConfig));
+ if(!ulCfg->pusch_ServingCellConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory Allocation failed in BuildUlCfg");
+ return RFAILED;
+ }
+
+ if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
+ {
+ return RFAILED;
+ }
+
+ ulCfg->carrierSwitching = NULLP;
+ ulCfg->ext1 = NULLP;
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds PDSCH serving cell config
+ * @details
+ *
+ * Function : BuildPdschSrvCellCfg
+ *
+ * Functionality: Builds PDSCH serving cell config in spCellCfgDed
+ *
+ * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
+{
+ pdschCfg->present = ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
+ pdschCfg->choice.setup = NULLP;
+ CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
+ if(!pdschCfg->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ return RFAILED;
+ }
+
+ pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
+ pdschCfg->choice.setup->xOverhead = NULLP;
+ pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
+ CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
+ if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ return RFAILED;
+ }
+ *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
+ pdschCfg->choice.setup->pucch_Cell = NULLP;
+ pdschCfg->choice.setup->ext1 = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds CSI Meas config
+ * @details
+ *
+ * Function : BuildCsiMeasCfg
+ *
+ * Functionality: Builds CSI Meas config in spCellCfgDed
+ *
+ * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
+{
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds Spcell config dedicated
+ * @details
+ *
+ * Function : BuildSpCellCfgDed
+ *
+ * Functionality: Builds sp cell config dedicated in spCellCfg
+ *
+ * @params[in] ServingCellConfig_t srvCellCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
+{
+ srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
+
+ srvCellCfg->initialDownlinkBWP = NULLP;
+ CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
+ if(!srvCellCfg->initialDownlinkBWP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+
+ if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildInitialDlBWP failed");
+ return RFAILED;
+ }
+ srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
+ srvCellCfg->downlinkBWP_ToAddModList = NULLP;
+
+ srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
+ CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
+ if(!srvCellCfg->firstActiveDownlinkBWP_Id)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+ *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
+
+ srvCellCfg->bwp_InactivityTimer = NULLP;
+
+ srvCellCfg->defaultDownlinkBWP_Id = NULLP;
+ CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
+ if(!srvCellCfg->defaultDownlinkBWP_Id)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+ *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
+
+ srvCellCfg->uplinkConfig = NULLP;
+ CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
+ if(!srvCellCfg->uplinkConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+
+ if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildUlCfg failed");
+ return RFAILED;
+ }
+ srvCellCfg->supplementaryUplink = NULLP;
+ srvCellCfg->pdcch_ServingCellConfig = NULLP;
+
+ srvCellCfg->pdsch_ServingCellConfig = NULLP;
+ CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
+ if(!srvCellCfg->pdsch_ServingCellConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+
+ if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildPdschSrvCellCfg failed");
+ return RFAILED;
+ }
+
+ srvCellCfg->csi_MeasConfig = NULLP;
+#if 0
+ CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct ServingCellConfig__csi_MeasConfig))
+ if(!srvCellCfg->csi_MeasConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+
+ if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
+ {
+ DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
+ return RFAILED;
+ }
+#endif
+ srvCellCfg->sCellDeactivationTimer = NULLP;
+ srvCellCfg->crossCarrierSchedulingConfig = NULLP;
+ srvCellCfg->tag_Id = TAG_ID;
+ srvCellCfg->dummy = NULLP;
+ srvCellCfg->pathlossReferenceLinking = NULLP;
+ srvCellCfg->servingCellMO = NULLP;
+ srvCellCfg->ext1 = NULLP;
+
+ return ROK;
+}
+/*******************************************************************
+ *
+ * @brief Builds Spcell config
+ *
+ * @details
+ *
+ * Function : BuildSpCellCfg
+ *
+ * Functionality: Builds sp cell config in DuToCuRrcContainer
+ *
+ * @params[in] SpCellConfig_t spCellCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
+{
+
+ spCellCfg->servCellIndex = NULLP;
+ CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
+ if(!spCellCfg->servCellIndex)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ return RFAILED;
+ }
+ *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
+
+ spCellCfg->reconfigurationWithSync = NULLP;
+ spCellCfg->rlf_TimersAndConstants = NULLP;
+ spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
+ CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
+ if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ return RFAILED;
+ }
+ *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
+
+ spCellCfg->spCellConfigDedicated = NULLP;
+ CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
+ if(!spCellCfg->spCellConfigDedicated)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSpCellCfg");
+ return RFAILED;
+ }
+ if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildSpCellCfgDed failed");
+ return RFAILED;
+ }
+ return ROK;
+}
+/*******************************************************************
+ *
+ * @brief Builds Phy cell group config
+ *
+ * @details
+ *
+ * Function : BuildPhyCellGrpCfg
+ *
+ * Functionality: Builds Phy cell group config in DuToCuRrcContainer
+ *
+ * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
+{
+ phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
+ phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
+
+ phyCellGrpCfg->p_NR_FR1 = NULLP;
+ CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
+ if(!phyCellGrpCfg->p_NR_FR1)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
+ return RFAILED;
+ }
+ *(phyCellGrpCfg->p_NR_FR1) = P_NR_FR1;
+ phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
+ phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
+ phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
+ phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
+ phyCellGrpCfg->sp_CSI_RNTI = NULLP;
+ phyCellGrpCfg->cs_RNTI = NULLP;
+ phyCellGrpCfg->ext1 = NULLP;
+ phyCellGrpCfg->ext2 = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds tag config
+ *
+ * @details
+ *
+ * Function : BuildTagConfig
+ *
+ * Functionality: Builds tag config in MacCellGroupConfig
+ *
+ * @params[in] TAG_Config *tag_Config
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
+{
+ struct TAG_Config__tag_ToAddModList *tagList;
+ uint8_t idx, elementCnt;
+
+ tagConfig->tag_ToReleaseList = NULLP;
+ tagConfig->tag_ToAddModList = NULLP;
+ CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
+ if(!tagConfig->tag_ToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
+ }
+
+ elementCnt = 1; //ODU_VALUE_ONE;
+ tagList = tagConfig->tag_ToAddModList;
+ tagList->list.count = elementCnt;
+ tagList->list.size = elementCnt * sizeof(struct TAG *);
+
+ tagList->list.array = NULLP;
+ CU_ALLOC(tagList->list.array, tagList->list.size);
+ if(!tagList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
+ }
+
+ for(idx=0; idx<tagList->list.count; idx++)
+ {
+ tagList->list.array[idx] = NULLP;
+ CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
+ if(!tagList->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ tagList->list.array[idx]->tag_Id = TAG_ID;
+ tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds PHR Config
+ *
+ * @details
+ *
+ * Function : BuildPhrConfig
+ *
+ * Functionality: Builds phrConfig in MacCellGroupConfig
+ *
+ * @params[in] PHR Config *
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
+{
+
+ phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
+ phrConfig->choice.setup = NULLP;
+ CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
+ if(!phrConfig->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildPhrConfig");
+ return RFAILED;
+ }
+
+ phrConfig->choice.setup->phr_PeriodicTimer = PHR_PERIODIC_TMR;
+ phrConfig->choice.setup->phr_ProhibitTimer = PHR_PROHIBHIT_TMR;
+ phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
+ phrConfig->choice.setup->multiplePHR = false;
+ phrConfig->choice.setup->dummy = false;
+ phrConfig->choice.setup->phr_Type2OtherCell = false;
+ phrConfig->choice.setup->phr_ModeOtherCG = PHR_MODE_OTHER_CG;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds BSR Config
+ *
+ * @details
+ *
+ * Function : BuildBsrConfig
+ *
+ * Functionality: Builds BuildBsrConfig in MacCellGroupConfig
+ *
+ * @params[in] BSR_Config *bsrConfig
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
+{
+ bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
+ bsrConfig->retxBSR_Timer = RETX_BSR_TMR;
+ bsrConfig->logicalChannelSR_DelayTimer = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds scheduling request config
+ *
+ * @details
+ *
+ * Function : BuildSchedulingReqConfig
+ *
+ * Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
+ *
+ * @params[in] SchedulingRequestConfig *schedulingRequestConfig
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
+{
+ struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
+ uint8_t idx, elementCnt;
+
+ schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
+ CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
+ sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
+ if(!schedulingRequestConfig->schedulingRequestToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ return RFAILED;
+ }
+
+ elementCnt = 1; //ODU_VALUE_ONE;
+ schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
+ schReqList->list.count = elementCnt;
+ schReqList->list.size = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
+
+ schReqList->list.array = NULLP;
+ CU_ALLOC(schReqList->list.array, schReqList->list.size);
+ if(!schReqList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ return RFAILED;
+ }
+
+ for(idx=0;idx<schReqList->list.count; idx++)
+ {
+ schReqList->list.array[idx] = NULLP;
+ CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
+ if(!schReqList->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
+
+ schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
+ CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
+ if(!schReqList->list.array[idx]->sr_ProhibitTimer)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ return RFAILED;
+ }
+ *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
+ schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
+ schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
+
+ return ROK;
+}
+/*******************************************************************
+ *
+ * @brief Builds Mac cell group config
+ *
+ * @details
+ *
+ * Function : BuildMacCellGrpCfg
+ *
+ * Functionality: Builds Mac cell group config in DuToCuRrcContainer
+ *
+ * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
+{
+ macCellGrpCfg->drx_Config = NULLP;
+ macCellGrpCfg->schedulingRequestConfig = NULLP;
+ CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
+ if(!macCellGrpCfg->schedulingRequestConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ return RFAILED;
+ }
+
+ if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildSchedulingReqConfig failed");
+ return RFAILED;
+ }
+
+ macCellGrpCfg->bsr_Config = NULLP;
+ CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
+ if(!macCellGrpCfg->bsr_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ return RFAILED;
+ }
+
+ if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildBsrConfig failed");
+ return RFAILED;
+ }
+
+ macCellGrpCfg->tag_Config = NULLP;
+ CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
+ if(!macCellGrpCfg->tag_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ return RFAILED;
+ }
+
+ if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildTagConfig failed");
+ return RFAILED;
+ }
+
+ macCellGrpCfg->phr_Config = NULLP;
+ CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
+ if(!macCellGrpCfg->phr_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacCellGrpCfg");
+ return RFAILED;
+ }
+
+ if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildPhrConfig failed");
+ return RFAILED;
+ }
+
+ macCellGrpCfg->skipUplinkTxDynamic = false;
+ macCellGrpCfg->ext1 = NULLP;
+
+ return ROK;
+}
+/*******************************************************************
+ *
+ * @brief Frees memeory allocated for SearchSpcToAddModList
+ *
+ * @details
+ *
+ * Function : FreeSearchSpcToAddModList
+ *
+ * Functionality: Deallocating memory of SearchSpcToAddModList
+ *
+ * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
+ *
+ * @return void
+ *
+ 4221 * ****************************************************************/
+void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
+{
+ uint8_t idx1=0;
+ uint8_t idx2=0;
+ struct SearchSpace *searchSpc=NULLP;
+
+ if(searchSpcList->list.array)
+ {
+ if(searchSpcList->list.array[idx2])
+ {
+ searchSpc = searchSpcList->list.array[idx2];
+ if(searchSpc->controlResourceSetId)
+ {
+ if(searchSpc->monitoringSlotPeriodicityAndOffset)
+ {
+ if(searchSpc->monitoringSymbolsWithinSlot)
+ {
+ if(searchSpc->monitoringSymbolsWithinSlot->buf)
+ {
+ if(searchSpc->nrofCandidates)
+ {
+ if(searchSpc->searchSpaceType)
+ {
+ CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
+ sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
+ CU_FREE(searchSpc->searchSpaceType, sizeof(struct
+ SearchSpace__searchSpaceType));
+ }
+ CU_FREE(searchSpc->nrofCandidates,
+ sizeof(struct SearchSpace__nrofCandidates));
+ }
+ CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
+ searchSpc->monitoringSymbolsWithinSlot->size);
+ }
+ CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
+ sizeof(BIT_STRING_t));
+ }
+ CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
+ sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
+ }
+ CU_FREE(searchSpc->controlResourceSetId,
+ sizeof(ControlResourceSetId_t));
+ }
+ }
+ for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
+ {
+ CU_FREE(searchSpcList->list.array[idx1],
+ sizeof(struct SearchSpace));
+ }
+ CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
+ }
+}
+/*******************************************************************
+ *
+ * @brief Frees memory allocated for PdschTimeDomAllocList
+ *
+ * @details
+ *
+ * Function : FreePdschTimeDomAllocList
+ *
+ * Functionality: Deallocating memory of PdschTimeDomAllocList
+ *
+ * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
+ *
+ * @return void
+ *
+ 4221 * ****************************************************************/
+void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
+{
+ uint8_t idx1=0;
+
+ if(timeDomAllocList->choice.setup)
+ {
+ if(timeDomAllocList->choice.setup->list.array)
+ {
+ for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
+ {
+ CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
+ sizeof(struct PDSCH_TimeDomainResourceAllocation));
+ }
+ CU_FREE(timeDomAllocList->choice.setup->list.array, \
+ timeDomAllocList->choice.setup->list.size);
+ }
+ CU_FREE(timeDomAllocList->choice.setup,\
+ sizeof(struct PDSCH_TimeDomainResourceAllocationList));
+ }
+}
+/*******************************************************************
+ *
+ * @brief Frees memory allocated for PuschTimeDomAllocList
+ *
+ *@details
+ *
+ * Function : FreePuschTimeDomAllocList
+ *
+ * Functionality: Deallocating memory of PuschTimeDomAllocList
+ *
+ * @params[in] PUSCH_Config_t *puschCfg
+ *
+ * @return void
+ *
+ ***********************************************************************/
+void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
+{
+ uint8_t idx1=0;
+ uint8_t idx2=0;
+ struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
+
+ if(puschCfg->pusch_TimeDomainAllocationList)
+ {
+ timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
+ if(timeDomAllocList_t->choice.setup)
+ {
+ if(timeDomAllocList_t->choice.setup->list.array)
+ {
+ CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
+ for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
+ {
+ CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
+ sizeof(PUSCH_TimeDomainResourceAllocation_t));
+ }
+ CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
+ timeDomAllocList_t->choice.setup->list.size);
+ }
+ CU_FREE(timeDomAllocList_t->choice.setup, \
+ sizeof(struct PUSCH_TimeDomainResourceAllocationList));
+ }
+ CU_FREE(puschCfg->transformPrecoder, sizeof(long));
+ CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
+ sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
+ }
+
+}
+
+/*******************************************************************
+ *
+ * @brief Frees memory allocated for Dedicated PUCCH config
+ *
+ * @details
+ *
+ * Function : FreeBWPUlDedPucchCfg
+ *
+ * Functionality: Deallocating memory of Dedicated PUCCH cfg
+ *
+ * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
+{
+ uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
+ PUCCH_Config_t *pucchCfg = NULLP;
+ PUCCH_ResourceSet_t *rsrcSet = NULLP;
+ PUCCH_Resource_t *rsrc = NULLP;
+
+ if(ulBwpPucchCfg)
+ {
+ if(ulBwpPucchCfg->choice.setup)
+ {
+ pucchCfg = ulBwpPucchCfg->choice.setup;
+
+ //Free resource set list
+ if(pucchCfg->resourceSetToAddModList)
+ {
+ if(pucchCfg->resourceSetToAddModList->list.array)
+ {
+ for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
+ {
+ rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
+ if(rsrcSet->resourceList.list.array)
+ {
+ for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
+ {
+ CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
+ }
+ CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
+ }
+ CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
+ }
+ CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
+ }
+ CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
+ }
+
+ //Free resource list
+ if(pucchCfg->resourceToAddModList)
+ {
+ if(pucchCfg->resourceToAddModList->list.array)
+ {
+ for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
+ {
+ rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
+ CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
+ CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
+ }
+ CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
+ }
+ CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
+ }
+
+ //PUCCH Format 1
+ if(pucchCfg->format1)
+ {
+ if(pucchCfg->format1->choice.setup)
+ {
+ CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
+ CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
+ }
+ CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
+ }
+
+ //DL DATA TO UL ACK
+ if(pucchCfg->dl_DataToUL_ACK)
+ {
+ if(pucchCfg->dl_DataToUL_ACK->list.array)
+ {
+ for(arrIdx = 0; arrIdx < pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
+ {
+ CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
+ }
+ CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
+ }
+ CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
+ }
+
+ CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
+ }
+ CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Frees memory allocated for InitialUlBWP
+ *
+ * @details
+ *
+ * Function : FreeInitialUlBWP
+ *
+ * Functionality: Deallocating memory of InitialUlBWP
+ *
+ * @params[in] BWP_UplinkDedicated_t *ulBwp
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
+{
+ uint8_t rSetIdx, rsrcIdx;
+ SRS_Config_t *srsCfg = NULLP;
+ PUSCH_Config_t *puschCfg = NULLP;
+ struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
+ struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
+ struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
+ struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
+
+ FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
+
+ if(ulBwp->pusch_Config)
+ {
+ if(ulBwp->pusch_Config->choice.setup)
+ {
+ puschCfg=ulBwp->pusch_Config->choice.setup;
+ if(puschCfg->dataScramblingIdentityPUSCH)
+ {
+ if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
+ {
+ FreePuschTimeDomAllocList(puschCfg);
+ dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
+ if(dmrsUlCfg->choice.setup)
+ {
+ if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
+ {
+ if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
+ {
+ CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
+ sizeof(long));
+ CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
+ sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
+ }
+ CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
+ sizeof(long));
+ }
+ CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
+ }
+ CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
+ sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
+ }
+ CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
+ }
+ CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
+ }
+ CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
+
+ /* Free SRS-Config */
+ if(ulBwp->srs_Config)
+ {
+ if(ulBwp->srs_Config->choice.setup)
+ {
+ srsCfg = ulBwp->srs_Config->choice.setup;
+
+ /* Free Resource Set to add/mod list */
+ if(srsCfg->srs_ResourceSetToAddModList)
+ {
+ rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
+ if(rsrcSetList->list.array)
+ {
+ rSetIdx = 0;
+
+ /* Free SRS resource Id list in this SRS resource set */
+ if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
+ {
+ rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
+
+ if(rsrcIdList->list.array)
+ {
+ for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
+ {
+ CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
+ }
+ CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
+ }
+ CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
+ sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
+ }
+
+ /* Free resource type info for this SRS resource set */
+ CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
+ sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
+
+ /* Free memory for each resource set */
+ for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
+ {
+ CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
+ }
+ CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
+ }
+ CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
+ sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
+ }
+
+ /* Free resource to add/modd list */
+ if(srsCfg->srs_ResourceToAddModList)
+ {
+ resourceList = srsCfg->srs_ResourceToAddModList;
+ if(resourceList->list.array)
+ {
+ rsrcIdx = 0;
+ CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
+ sizeof(struct SRS_Resource__transmissionComb__n2));
+ CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
+ sizeof(struct SRS_Resource__resourceType__aperiodic));
+
+ for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
+ {
+ CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
+ }
+ CU_FREE(resourceList->list.array, resourceList->list.size);
+ }
+ CU_FREE(srsCfg->srs_ResourceToAddModList, \
+ sizeof(struct SRS_Config__srs_ResourceToAddModList));
+ }
+
+ CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
+ }
+ CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
+ }
+ }
+}
+/*******************************************************************
+ *
+ * @brief Frees memory allocated for initialUplinkBWP
+ *
+ * @details
+ *
+ * Function : FreeinitialUplinkBWP
+ *
+ * Functionality: Deallocating memory of initialUplinkBWP
+ *
+ * @params[in] UplinkConfig_t *ulCfg
+ *
+ * @return void
+ *
+ *
+ * ****************************************************************/
+void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
+{
+ BWP_UplinkDedicated_t *ulBwp=NULLP;
+ struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
+
+ if(ulCfg->initialUplinkBWP)
+ {
+ ulBwp=ulCfg->initialUplinkBWP;
+ if(ulCfg->firstActiveUplinkBWP_Id)
+ {
+ if(ulCfg->pusch_ServingCellConfig)
+ {
+ puschCfg=ulCfg->pusch_ServingCellConfig;
+ if(puschCfg->choice.setup)
+ {
+ if(puschCfg->choice.setup->ext1)
+ {
+ CU_FREE(puschCfg->choice.setup->ext1->\
+ processingType2Enabled,sizeof(BOOLEAN_t));
+ CU_FREE(puschCfg->choice.setup->ext1->\
+ maxMIMO_Layers,sizeof(long));
+ CU_FREE(puschCfg->choice.setup->ext1, \
+ sizeof(struct PUSCH_ServingCellConfig__ext1));
+ }
+ CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
+ }
+ CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
+ }
+ CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
+ }
+ FreeInitialUlBWP(ulBwp);
+ CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
+ }
+}
+/*******************************************************************
+ *
+ * @brief Frees emmory allocated for BWPDlDedPdschCfg
+ *
+ * @details
+ *
+ * Function : FreeBWPDlDedPdschCfg
+ *
+ * Functionality: Deallocating memory of BWPDlDedPdschCfg
+ *
+ * @params[in] BWP_DownlinkDedicated_t *dlBwp
+ *
+ * @return void
+ *
+ *
+ * ****************************************************************/
+void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
+{
+ struct PDSCH_Config *pdschCfg=NULLP;
+ struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
+ struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
+ struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
+
+ if(dlBwp->pdsch_Config->choice.setup)
+ {
+ pdschCfg=dlBwp->pdsch_Config->choice.setup;
+ if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
+ {
+ if(pdschCfg->pdsch_TimeDomainAllocationList)
+ {
+ timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
+ if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
+ {
+ prbBndlType=&pdschCfg->prb_BundlingType;
+ CU_FREE(prbBndlType->choice.staticBundling,\
+ sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
+ CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
+ }
+ FreePdschTimeDomAllocList(timeDomAllocList);
+ CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
+ sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
+ }
+ dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
+ if(dmrsDlCfg->choice.setup)
+ {
+ CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
+ sizeof(long));
+ CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
+ }
+ CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
+ sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
+ }
+ CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
+ }
+}
+/*******************************************************************
+ *
+ * @brief Frees emmory allocated for BWPDlDedPdcchCfg
+ *
+ * @details
+ *
+ * Function : FreeBWPDlDedPdcchCfg
+ *
+ * Functionality: Deallocating memory of BWPDlDedPdcchCfg
+ *
+ * @params[in] BWP_DownlinkDedicated_t *dlBwp
+ *
+ * @return void
+ *
+ *
+ * ****************************************************************/
+void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
+{
+ uint8_t idx1=0;
+ uint8_t idx2=0;
+ struct PDCCH_Config *pdcchCfg=NULLP;
+ struct ControlResourceSet *controlRSet=NULLP;
+ struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
+
+ if(dlBwp->pdcch_Config->choice.setup)
+ {
+ pdcchCfg=dlBwp->pdcch_Config->choice.setup;
+ if(pdcchCfg->controlResourceSetToAddModList)
+ {
+ controlRSetList = pdcchCfg->controlResourceSetToAddModList;
+ if(controlRSetList->list.array)
+ {
+ controlRSet = controlRSetList->list.array[idx2];
+ if(controlRSet)
+ {
+ if(controlRSet->frequencyDomainResources.buf)
+ {
+ if(controlRSet->pdcch_DMRS_ScramblingID)
+ {
+ if(pdcchCfg->searchSpacesToAddModList)
+ {
+ FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
+ CU_FREE(pdcchCfg->searchSpacesToAddModList, \
+ sizeof(struct PDCCH_Config__searchSpacesToAddModList));
+ }
+ CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
+ }
+ CU_FREE(controlRSet->frequencyDomainResources.buf, \
+ controlRSet->frequencyDomainResources.size);
+ }
+ }
+ for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
+ {
+ CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
+ }
+ CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
+ }
+ CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
+ sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
+ }
+ CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
+ }
+}
+/*******************************************************************
+ *
+ * @brief Builds RLC Config
+ *
+ * @details
+ *
+ * Function : BuildRlcConfig
+ *
+ * Functionality: Builds RLC Config in BuildRlcBearerToAddModList
+ *
+ * @params[in] RLC_Config *rlcConfig
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
+{
+ rlcConfig->present = rlcLcCfgDb.rlcMode;
+
+ switch(rlcConfig->present)
+ {
+ case RLC_Config_PR_am:
+ {
+ rlcConfig->choice.am = NULLP;
+ CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
+ if(!rlcConfig->choice.am)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+
+ /* UL */
+ rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
+ CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
+ rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
+ rlcConfig->choice.am->ul_AM_RLC.pollPDU = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
+ rlcConfig->choice.am->ul_AM_RLC.pollByte = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
+ rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
+
+ /* DL */
+ rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
+ CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
+ rlcConfig->choice.am->dl_AM_RLC.t_Reassembly = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
+ rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
+
+ break;
+ }
+
+ case RLC_Config_PR_um_Bi_Directional:
+ {
+ rlcConfig->choice.um_Bi_Directional = NULLP;
+ CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
+ if(!rlcConfig->choice.um_Bi_Directional)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+
+ /* UL */
+ rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
+ CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
+ if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
+
+ /* DL */
+ rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
+ CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
+ if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
+ rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
+ break;
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds MAC LC Config
+ *
+ * @details
+ *
+ * Function : BuildMacLCConfig
+ *
+ * Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
+ *
+ * @params[in] struct LogicalChannelConfig macLcConfig
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
+{
+
+ macLcConfig->ul_SpecificParameters = NULLP;
+ CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
+ if(!macLcConfig->ul_SpecificParameters)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
+ return RFAILED;
+ }
+
+ macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
+ macLcConfig->ul_SpecificParameters->prioritisedBitRate = macLcCfgDb.pbr;
+ macLcConfig->ul_SpecificParameters->bucketSizeDuration = macLcCfgDb.bsd;
+ macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
+ macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
+ macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
+ macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
+
+ macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
+ CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
+ if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
+ return RFAILED;
+ }
+ *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
+
+ macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
+ CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
+ if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildMacLCConfig");
+ return RFAILED;
+ }
+ *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
+
+ macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
+ macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
+ macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
+
+ return ROK;
+}
+/*******************************************************************
+ *
+ * @brief Builds RLC Bearer to Add/Mod list
+ *
+ * @details
+ *
+ * Function :BuildRlcBearerToAddModList
+ *
+ * Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
+ *
+ * @params[in] rlc_BearerToAddModList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
+{
+ uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
+
+ if(updateAllRbCfg)
+ elementCnt = ueCb->numSrb + ueCb->numDrb;
+ else
+ {
+ for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
+ {
+ if(ueCb->srbList[srbIdx].cfgSentToUe == false)
+ elementCnt++;
+ }
+
+ for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
+ {
+ if(ueCb->drbList[drbIdx].cfgSentToUe == false)
+ elementCnt++;
+ }
+ }
+
+ rlcBearerList->list.count = elementCnt;
+ rlcBearerList->list.size = elementCnt * sizeof(struct RLC_BearerConfig *);
+
+ rlcBearerList->list.array = NULLP;
+ CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
+ if(!rlcBearerList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ for(idx=0; idx<rlcBearerList->list.count; idx++)
+ {
+ rlcBearerList->list.array[idx] = NULLP;
+ CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
+ if(!rlcBearerList->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+
+ for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
+ {
+ if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
+ continue;
+
+ rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
+
+ CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
+ if(!rlcBearerList->list.array[idx]->servedRadioBearer)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
+ rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
+
+ rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
+ rlcBearerList->list.array[idx]->rlc_Config = NULLP;
+ CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
+ if(!rlcBearerList->list.array[idx]->rlc_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
+ return RFAILED;
+ }
+
+ rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
+ CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
+ if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
+ return RFAILED;
+ }
+ idx++;
+ }
+
+ for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
+ {
+ if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
+ continue;
+
+ rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
+
+ CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
+ if(!rlcBearerList->list.array[idx]->servedRadioBearer)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
+ rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
+
+ rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
+ rlcBearerList->list.array[idx]->rlc_Config = NULLP;
+ CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
+ if(!rlcBearerList->list.array[idx]->rlc_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildRlcConfig failed");
+ return RFAILED;
+ }
+
+ rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
+ CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
+ if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildMacLCConfig failed");
+ return RFAILED;
+ }
+ idx++;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Free memory allocated for CellGroupConfig
+ *
+ * @details
+ *
+ * Function : FreeMemCellGrpCfg
+ *
+ * Functionality: Deallocating memory of CellGroupConfig
+ *
+ * @params[in] pointer to CellGroupConfigRrc_t
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
+{
+ uint8_t idx=0;
+ SpCellConfig_t *spCellCfg=NULLP;
+ ServingCellConfig_t *srvCellCfg=NULLP;
+ BWP_DownlinkDedicated_t *dlBwp=NULLP;
+ MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
+ PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
+ struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
+ struct RLC_Config *rlcConfig=NULLP;
+ struct LogicalChannelConfig *macLcConfig=NULLP;
+ struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
+ struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
+ struct TAG_Config *tagConfig=NULLP;
+ struct TAG_Config__tag_ToAddModList *tagList=NULLP;
+ struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
+ struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
+
+ rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
+ if(rlcBearerList)
+ {
+ if(rlcBearerList->list.array)
+ {
+ for(idx=0; idx<rlcBearerList->list.count; idx++)
+ {
+ if(rlcBearerList->list.array[idx])
+ {
+ rlcConfig = rlcBearerList->list.array[idx]->rlc_Config;
+ macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
+ if(rlcConfig)
+ {
+ if(rlcConfig->choice.am)
+ {
+ CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
+ }
+ CU_FREE(rlcConfig, sizeof(struct RLC_Config));
+ }
+ CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
+ if(macLcConfig)
+ {
+ if(macLcConfig->ul_SpecificParameters)
+ {
+ CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
+ CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
+ CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
+ }
+ CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
+ }
+ CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
+ }
+ }
+ CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
+ }
+ CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
+ }
+
+ macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
+ if(macCellGrpCfg)
+ {
+ schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
+ if(schedulingRequestConfig)
+ {
+ schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
+ if(schReqList)
+ {
+ if(schReqList->list.array)
+ {
+ for(idx=0;idx<schReqList->list.count; idx++)
+ {
+ if(schReqList->list.array[idx])
+ {
+ CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
+ CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
+ }
+ }
+ CU_FREE(schReqList->list.array, schReqList->list.size);
+ }
+ CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
+ sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList)); }
+ CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
+ }
+ if(macCellGrpCfg->bsr_Config)
+ {
+ CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
+ }
+ tagConfig = macCellGrpCfg->tag_Config;
+ if(tagConfig)
+ {
+ tagList = tagConfig->tag_ToAddModList;
+ if(tagList)
+ {
+ if(tagList->list.array)
+ {
+ for(idx=0; idx<tagList->list.count; idx++)
+ {
+ CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
+ }
+ CU_FREE(tagList->list.array, tagList->list.size);
+ }
+ CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
+ }
+ CU_FREE(tagConfig, sizeof(struct TAG_Config));
+ }
+
+ phrConfig = macCellGrpCfg->phr_Config;
+ if(phrConfig)
+ {
+ CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
+ CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
+ }
+
+ CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
+ }
+
+ phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
+ if(phyCellGrpCfg)
+ {
+ CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
+ CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
+ }
+
+ spCellCfg = cellGrpCfg->spCellConfig;
+ if(spCellCfg)
+ {
+ if(spCellCfg->servCellIndex)
+ {
+ if(spCellCfg->rlmInSyncOutOfSyncThreshold)
+ {
+ if(spCellCfg->spCellConfigDedicated)
+ {
+ srvCellCfg = spCellCfg->spCellConfigDedicated;
+ if(srvCellCfg->initialDownlinkBWP)
+ {
+ dlBwp = srvCellCfg->initialDownlinkBWP;
+ if(srvCellCfg->firstActiveDownlinkBWP_Id)
+ {
+ if(srvCellCfg->defaultDownlinkBWP_Id)
+ {
+ if(srvCellCfg->uplinkConfig)
+ {
+ if(srvCellCfg->pdsch_ServingCellConfig)
+ {
+ pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
+ if(pdschCfg->choice.setup)
+ {
+ CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
+ CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
+ }
+ CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
+ ServingCellConfig__pdsch_ServingCellConfig));
+ }
+ FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
+ CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
+ }
+ CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
+ }
+ CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
+ }
+ if(dlBwp->pdcch_Config)
+ {
+ if(dlBwp->pdsch_Config)
+ {
+ FreeBWPDlDedPdschCfg(dlBwp);
+ CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
+ }
+ FreeBWPDlDedPdcchCfg(dlBwp);
+ CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
+ }
+ CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
+ }
+ CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
+ }
+ CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
+ }
+ CU_FREE(spCellCfg->servCellIndex, sizeof(long));
+ }
+ CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills CellGroupConfig
+ *
+ * @details
+ *
+ * Function : fillCellGrpCfg
+ *
+ * Functionality: Fills CellGroupConfig
+ *
+ * @params[in] pointer to CellGroupConfigRrc_t
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
+{
+ uint8_t ret = RFAILED;
+ CellGroupConfigRrc_t cellGrpCfg;
+ asn_enc_rval_t encRetVal;
+
+ while(true)
+ {
+ cellGrpCfg.cellGroupId = CELL_GRP_ID;
+
+ cellGrpCfg.rlc_BearerToAddModList = NULLP;
+ CU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
+ if(!cellGrpCfg.rlc_BearerToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in CellGrpConfig");
+ break;
+ }
+ if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : fillCellGrpCfg failed");
+ break;
+ }
+
+ cellGrpCfg.rlc_BearerToReleaseList = NULLP;
+ cellGrpCfg.mac_CellGroupConfig = NULLP;
+ CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
+ if(!cellGrpCfg.mac_CellGroupConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in fillCellGrpCfg");
+ break;
+ }
+ if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildMacCellGrpCfg failed");
+ break;
+ }
+
+ cellGrpCfg.physicalCellGroupConfig = NULLP;
+ CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
+ if(!cellGrpCfg.physicalCellGroupConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ break;
+ }
+ if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildPhyCellGrpCfg failed");
+ break;
+ }
+
+ cellGrpCfg.spCellConfig = NULLP;
+ CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
+ if(!cellGrpCfg.spCellConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
+ break;
+ }
+ if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildSpCellCfg failed");
+ break;
+ }
+
+ cellGrpCfg.sCellToAddModList = NULLP;
+ cellGrpCfg.sCellToReleaseList = NULLP;
+ cellGrpCfg.ext1 = NULLP;
+
+ /* encode cellGrpCfg into duToCuRrcContainer */
+ xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ cellGrp->size = encBufSize;
+ CU_ALLOC(cellGrp->buf, cellGrp->size);
+ if(!cellGrp->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
+ break;
+ }
+ memcpy(cellGrp->buf, encBuf, cellGrp->size);
+ ret = ROK;
+ break;
+ }
+ FreeMemCellGrpCfg(&cellGrpCfg);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Free UE Capability RAT container
+ *
+ * @details
+ *
+ * Function : freeUeCapRatCont
+ *
+ * Functionality:
+ * Free UE Capability RAT conatiner
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
+{
+ uint8_t idx;
+ FeatureSets_t *featureSets;
+
+ if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
+ {
+ for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
+ {
+ if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
+ CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
+ }
+ CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
+ }
+
+ if(ueNrCap->featureSets)
+ {
+ featureSets = ueNrCap->featureSets;
+ if(featureSets->featureSetsDownlinkPerCC)
+ {
+ if(featureSets->featureSetsDownlinkPerCC->list.array)
+ {
+ for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
+ {
+ if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
+ CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
+ sizeof(ModulationOrder_t));
+ CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
+ }
+ CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
+ }
+ CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
+ }
+
+ if(featureSets->featureSetsUplinkPerCC)
+ {
+ if(featureSets->featureSetsUplinkPerCC->list.array)
+ {
+ for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
+ {
+ if(featureSets->featureSetsUplinkPerCC->list.array[idx])
+ {
+ if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
+ CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
+ sizeof(ModulationOrder_t));
+ CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
+ }
+ }
+ CU_FREE(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
+ }
+ CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
+ }
+ CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Free UE capability RAT container list
+ *
+ * @details
+ *
+ * Function : freeUeCapRatContList
+ *
+ * Functionality: Free UE capability RAT container list
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
+{
+ uint8_t idx;
+ if(ueCapablityList->list.array)
+ {
+ for(idx = 0; idx < ueCapablityList->list.count; idx++)
+ {
+ if(ueCapablityList->list.array[idx])
+ CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
+ }
+ CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Free Handover preparation information
+ *
+ * @details
+ *
+ * Function : freeHOPreparationInfo
+ *
+ * Functionality: Free Handover preparation information
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
+{
+ HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
+
+ if(hoPrep->criticalExtensions.choice.c1)
+ {
+ if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
+ {
+ hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
+ freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
+ CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
+ sizeof(HandoverPreparationInformationRrc_IEs_t));
+ }
+ CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fill feature sets
+ *
+ * @details
+ *
+ * Function : fillFeatureSets
+ *
+ * Functionality: Fill feature sets
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillFeatureSets(FeatureSets_t *featureSets)
+{
+ uint8_t idx, elementCnt;
+
+ featureSets->featureSetsDownlink = NULLP;
+ CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
+ if(!featureSets->featureSetsDownlinkPerCC)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
+ featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
+ CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
+ if(!featureSets->featureSetsDownlinkPerCC->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
+ if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
+ featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
+ featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
+ featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
+ featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
+
+ CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
+ if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ return RFAILED;
+ }
+ *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
+
+ featureSets->featureSetsUplink = NULLP;
+ CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
+ if(!featureSets->featureSetsUplinkPerCC)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
+ featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
+ CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
+ if(!featureSets->featureSetsUplinkPerCC->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
+ if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
+ featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
+ featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
+ featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
+ featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
+ featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
+
+ CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
+ if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillFeatureSets");
+ return RFAILED;
+ }
+ *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill UE capability RAT container
+ *
+ * @details
+ *
+ * Function : fillUeCapRatCont
+ *
+ * Functionality: Fill UE capability RAT container
+ *
+ * @params[in] UE Capability RAT container buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
+{
+ uint8_t ret = ROK;
+ uint8_t idx, elementCnt;
+ asn_enc_rval_t encRetVal;
+ UE_NR_Capability_t ueNrCap;
+
+ while(true)
+ {
+ ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
+
+ /* Filling PDCP parameters */
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
+ ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
+ ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
+ ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
+ ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
+ ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
+ ueNrCap.pdcp_Parameters.shortSN = NULLP;
+ ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
+ ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
+
+ ueNrCap.rlc_Parameters = NULLP;
+ ueNrCap.mac_Parameters = NULLP;
+
+ /* Filling PHY parameters */
+ ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
+ ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
+ ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
+ ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
+ ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
+
+ /* Filling RF parameters */
+ elementCnt = 1;
+ ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
+ ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
+ CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
+ if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapRatCont");
+ ret = RFAILED;
+ break;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
+ if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
+ {
+ ret = RFAILED;
+ break;
+ }
+ }
+ if(ret == RFAILED)
+ break;
+
+ idx = 0;
+ ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
+ ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
+ ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
+
+ ueNrCap.measAndMobParameters = NULLP;
+ ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
+ ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
+ ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
+ ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
+ ueNrCap.featureSets = NULLP;
+
+ CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
+ if(!ueNrCap.featureSets)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapRatCont");
+ ret = RFAILED;
+ break;
+ }
+
+ if(fillFeatureSets(ueNrCap.featureSets) != ROK)
+ {
+ DU_LOG("\nERROR --> fillDLFeatureSets() failed ");
+ ret = RFAILED;
+ break;
+ }
+
+ ueNrCap.featureSetCombinations = NULLP;
+ ueNrCap.lateNonCriticalExtension = NULLP;
+ ueNrCap.nonCriticalExtension = NULLP;
+
+ /* encode UE Capability RAT Container List into duToCuRrcContainer */
+ xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ ueCapRatContBuf->size = encBufSize;
+ CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
+ if(!ueCapRatContBuf->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
+ break;
+ }
+ memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
+ ret = ROK;
+ break;
+ }
+ freeUeCapRatCont(&ueNrCap);
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill UE Capability RAT container list
+ *
+ * @details
+ *
+ * Function : fillUeCapRatContList
+ *
+ * Functionality: Fill UE Capability RAT container list
+
+ *
+ * @params[in] UE capability RAT container list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
+{
+ uint8_t ret = RFAILED;
+ uint8_t idx, elementCnt;
+
+ while(true)
+ {
+ elementCnt = 1;
+ ueCapablityList->list.count = elementCnt;
+ ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
+
+ CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
+ if(!ueCapablityList->list.array)
+ {
+ DU_LOG("\nERROR --> Memory allocation failed in fillUeCapRatContList");
+ ret = RFAILED;
+ break;
+ }
+
+ for(idx=0; idx<elementCnt; idx++)
+ {
+ CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
+ if(ueCapablityList->list.array[idx] == NULLP)
+ {
+ DU_LOG("\nERROR --> Memory allocation failed in fillUeCapRatContList");
+ ret = RFAILED;
+ break;
+ }
+ }
+ idx = 0;
+ ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
+ if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to fill UE capability RAT Conatiner");
+ ret = RFAILED;
+ break;
+ }
+
+ ret = ROK;
+ break;
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill UE Capability RAT container list octet string
+ *
+ * @details
+ *
+ * Function : fillUeCapRatContListBuf
+ *
+ * Functionality: Fill UE Capability RAT container list octet string
+
+ *
+ * @params[in] UE capability RAT container list buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
+{
+ uint8_t ret = RFAILED;
+ asn_enc_rval_t encRetVal;
+ UE_CapabilityRAT_ContainerListRRC_t ueCapablityList;
+
+ while(true)
+ {
+ ret = fillUeCapRatContList(&ueCapablityList);
+ if(ret != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to fill UE Capability RAT container list");
+ break;
+ }
+
+ /* encode UE Capability RAT Container List into duToCuRrcContainer */
+ xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
+ &ueCapablityList, PrepFinalEncBuf, encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ ueCapablityListBuf->size = encBufSize;
+ CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
+ if(!ueCapablityListBuf->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
+ break;
+ }
+ memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
+ ret = ROK;
+ break;
+ }
+ freeUeCapRatContList(&ueCapablityList);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Free Measurement Timing Configuration
+ *
+ * @details
+ *
+ * Function : freeMeasuementTimingConfig
+ *
+ * Functionality: Free Measurement Timing Configuration
+ *
+ * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
+ * @return void
+ *
+ * ****************************************************************/
+void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
+{
+ uint8_t measCfgIdx;
+ MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
+ MeasTiming_t *measTiming = NULLP;
+
+ if(measTimingConfig.criticalExtensions.choice.c1)
+ {
+ if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
+ {
+ measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
+ if(measTimingCfg->measTiming)
+ {
+ if(measTimingCfg->measTiming->list.array)
+ {
+ for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
+ {
+ measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
+ CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
+ CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
+ }
+ CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
+ }
+ CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
+ }
+ CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
+ }
+ CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fill Measurement Timing Configuration
+ *
+ * @details
+ *
+ * Function : fillMeasTimingCfg
+ *
+ * Functionality: Fill Measurement Timing Configuration
+ *
+ * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
+{
+ uint8_t elementCnt = 0;
+ uint8_t measCfgIdx = 0;
+ MeasTiming_t *measTiming;
+ SSB_MTC_t *smtc;
+
+ CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
+ if(!measTimingCfg->measTiming)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measTiming in fillMeasTimingCfg");
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ measTimingCfg->measTiming->list.count = elementCnt;
+ measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
+ CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
+ if(!measTimingCfg->measTiming->list.array)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
+ return RFAILED;
+ }
+
+ for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
+ {
+ CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
+ if(!measTimingCfg->measTiming->list.array[measCfgIdx])
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
+ return RFAILED;
+ }
+ }
+
+ measCfgIdx = 0;
+ measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
+ CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
+ if(!measTiming->frequencyAndTiming)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
+ return RFAILED;
+ }
+
+ measTiming->frequencyAndTiming->carrierFreq = 623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
+ measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
+
+ smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
+ smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
+ smtc->periodicityAndOffset.choice.sf20 = 0;
+ smtc->duration = SSB_MTC__duration_sf1;
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill Measurement Timing Configuration Octet string
+ *
+ * @details
+ *
+ * Function : fillMeasConfigBuf
+ *
+ * Functionality: Fill Measurement Timing Configuration Octet string
+
+ *
+ * @params[in] MeasConfig_t *measConfgBuf
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
+{
+ uint8_t ret = RFAILED;
+ asn_enc_rval_t encRetVal;
+ MeasurementTimingConfigurationRrc_t measTimingConfig;
+
+ while(true)
+ {
+ measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
+ CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
+ if(!measTimingConfig.criticalExtensions.choice.c1)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measurement configuration extension");
+ return RFAILED;
+ }
+ measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
+
+ CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
+ if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocated memory for measurement timing configuration IE");
+ return RFAILED;
+ }
+
+ ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
+ if(ret != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to fill measurement timing configuration IE");
+ break;
+ }
+
+ /* Encode measurement timing configuration into octet string */
+ xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ measTimingConfigBuf->size = encBufSize;
+ CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
+ if(!measTimingConfigBuf->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed fillMeasTimingConfigBuf");
+ break;
+ }
+ memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
+ ret = ROK;
+ break;
+ }
+ freeMeasuementTimingConfig(measTimingConfig);
+ return ret;
+}
+
+/******************************************************************
+ *
+ * @brief Free RRC reconfiguration non-critical extension
+ *
+ * @details
+ *
+ * Function : freeRrcReconfigNonCriticalExt
+ *
+ * Functionality: Free RRC reconfiguration non-critical extension
+ *
+ * @params[in] RRC reconfiguration IE
+ * @return void
+ *
+ * ****************************************************************/
+void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
+{
+ if(rrcRecfg->masterCellGroup)
+ {
+ CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Free measurement object addmod list
+ *
+ * @details
+ *
+ * Function : freeMeasObjToAddModList
+ *
+ * Functionality: Free measurement object add mod list
+ *
+ * @params[in] Measurement object add/mod list
+ * @return void
+ *
+ * ****************************************************************/
+void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
+{
+ uint8_t objIdx;
+ MeasObjectNR_t *measObject;
+
+ if(measObjList->list.array)
+ {
+ for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
+ {
+ if(measObjList->list.array[objIdx])
+ {
+ if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
+ {
+ measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
+ CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
+ CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
+ CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
+ if(measObject->absThreshSS_BlocksConsolidation)
+ {
+ CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
+ CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
+ CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
+ CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
+ }
+ CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
+ CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
+ CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
+ CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
+ CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
+ }
+ CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
+ }
+ }
+ CU_FREE(measObjList->list.array, measObjList->list.size);
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Free report config add mod list
+ *
+ * @details
+ *
+ * Function : freeReportCfgToAddModList
+ *
+ * Functionality: Free report config add mod list
+ *
+ * @params[in] Report config list
+ * @return void
+ *
+ * ****************************************************************/
+void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
+{
+ uint8_t reportCfgIdx;
+ ReportConfigToAddMod_t *reportCfg;
+ ReportConfigNR_t *reportCfgNr;
+ EventTriggerConfig_t *eventTriggCfg;
+
+ if(reportCfgList->list.array)
+ {
+ for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
+ {
+ if(reportCfgList->list.array[reportCfgIdx])
+ {
+ reportCfg = reportCfgList->list.array[reportCfgIdx];
+ if(reportCfg->reportConfig.choice.reportConfigNR)
+ {
+ reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
+ if(reportCfgNr->reportType.choice.eventTriggered)
+ {
+ eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
+ CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
+ CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
+ CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
+ CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
+ }
+ }
+ }
+ CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
+ }
+ CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Free measurement id to add mod list
+ *
+ * @details
+ *
+ * Function : freeMeasIdToAddModList
+ *
+ * Functionality: Free measurement id to add mod list
+ *
+ * @params[in] Measurement id to add mod list
+ * @return void
+ *
+ * ****************************************************************/
+void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
+{
+ uint8_t measIdIdx;
+ if(measIdList->list.array)
+ {
+ for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
+ {
+ CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
+ }
+ CU_FREE(measIdList->list.array, measIdList->list.size);
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Free quantity config
+ *
+ * @details
+ *
+ * Function : freeQunatityConfig
+ *
+ * Functionality: Free quantity config
+ *
+ * @params[in] Quantity Config
+ * @return void
+ *
+ * ****************************************************************/
+uint8_t freeQuantityConfig(QuantityConfig_t *quantityCfg)
+{
+ uint8_t quanCfgIdx;
+ QuantityConfigNR_t *quantityCfgNr;
+
+ if(quantityCfg->quantityConfigNR_List)
+ {
+ if(quantityCfg->quantityConfigNR_List->list.array)
+ {
+ for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
+ {
+ if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
+ {
+ quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
+ CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
+ if(quantityCfgNr->quantityConfigRS_Index)
+ {
+ CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
+ CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
+ }
+ CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
+ }
+ }
+ CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
+ }
+ CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Free measurement Config
+ *
+ * @details
+ *
+ * Function : freeMeasConfig
+ *
+ * Functionality: Free measurement config
+ *
+ * @params[in] Measurement config
+ * @return void
+ *
+ * ****************************************************************/
+void freeMeasConfig(MeasConfigRrc_t *measConfig)
+{
+ if(measConfig->measObjectToAddModList)
+ {
+ freeMeasObjToAddModList(measConfig->measObjectToAddModList);
+ CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
+ }
+ if(measConfig->reportConfigToAddModList)
+ {
+ freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
+ CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
+ }
+ if(measConfig->measIdToAddModList)
+ {
+ freeMeasIdToAddModList(measConfig->measIdToAddModList);
+ CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
+ }
+ if(measConfig->s_MeasureConfig)
+ {
+ CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
+ }
+ if(measConfig->quantityConfig)
+ {
+ freeQuantityConfig(measConfig->quantityConfig);
+ CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
+ }
+}
+/******************************************************************
+ *
+ * @brief Free DRB to AddMod List
+ *
+ * @details
+ *
+ * Function : freeDrbToAddModList
+ *
+ * Functionality: Free SRB to AddMod List
+ *
+ * @params[in] SBR to add/mod list
+ * @return void
+ *
+ * ****************************************************************/
+void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
+{
+ uint8_t drbIdx;
+ if(drbToAddList->list.array)
+ {
+ for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
+ {
+ if(drbToAddList->list.array[drbIdx]->pdcp_Config)
+ {
+ if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
+ {
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
+ }
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
+ CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
+ }
+ CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
+ }
+ CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Free SRB to AddMod List
+ *
+ * @details
+ *
+ * Function : freeSrbToAddModList
+ *
+ * Functionality: Free SRB to AddMod List
+ *
+ * @params[in] SBR to add/mod list
+ * @return void
+ *
+ * ****************************************************************/
+void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
+{
+ uint8_t srbIdx;
+ if(srbToAddList->list.array)
+ {
+ for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
+ {
+ CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
+ if(srbToAddList->list.array[srbIdx]->pdcp_Config)
+ {
+ CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
+ CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
+ }
+
+ CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
+ }
+ CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Free Radio Bearer Config
+ *
+ * @details
+ *
+ * Function : fillRadioBearerConfig
+ *
+ * Functionality: Free Radio Bearer config
+ *
+ * @params[in] Radio bearer config
+ * @return void
+ *
+ * ****************************************************************/
+void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
+{
+ if(radioBearerConfig->srb_ToAddModList)
+ {
+ freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
+ CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
+ }
+ if(radioBearerConfig->drb_ToAddModList)
+ {
+ freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
+ CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Free reconfiguration message
+ *
+ * @details
+ *
+ * Function : freeRrcReconfig
+ *
+ * Functionality: Free reconfiguration message
+ *
+ * @params[in] RRC Reconfiguration message
+ * @return void
+ *
+ * ****************************************************************/
+void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
+{
+ if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
+ {
+ if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
+ {
+ freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
+ CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
+ }
+ if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
+ {
+ freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
+ CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
+ }
+ if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
+ {
+ freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
+ CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
+ }
+ CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
+ }
+}
+
+/******************************************************************
+ *
+ * @brief Fill SRB To Add Mod list
+ *
+ * @details
+ *
+ * Function : fillSrbToAddModList
+ *
+ * Functionality: fill SRB to Add Mod list
+ *
+ * @params[in] UE control block
+ * SRB to Add/Mod list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
+{
+ uint8_t srbIdx, srbDbIdx;
+
+ if(updateAllRbCfg)
+ srbToAddList->list.count = ueCb->numSrb;
+ else
+ {
+ srbToAddList->list.count = 0;
+ for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
+ {
+ if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
+ srbToAddList->list.count++;
+ }
+ }
+ srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
+
+ CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
+ if(!srbToAddList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
+ return RFAILED;
+ }
+
+ srbIdx = 0;
+ for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
+ {
+ if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
+ continue;
+
+ CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
+ if(!srbToAddList->list.array[srbIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
+ return RFAILED;
+ }
+
+ srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
+
+ /* Reestablish PDCP */
+ CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
+ if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
+ return RFAILED;
+ }
+ *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
+
+ /* PDCP configuration */
+ CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
+ if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
+ return RFAILED;
+ }
+
+ /* Reordering timer */
+ CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
+ if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
+ return RFAILED;
+ }
+ *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
+
+ srbIdx++;
+ }
+ return ROK;
+}
+
+/******************************************************************
+ *
+ * @biief Fill DRBeTo Add Mod list
+ *
+ * @details
+ *
+ * Function : fillDrbToAddModList
+ *
+ * Functionality: fill DRB to Add Mod list
+ *
+ * @params[in] UE control block
+ * DRB to Add/Mod list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
+{
+ uint8_t drbIdx, drbDbIdx;
+
+ if(updateAllRbCfg)
+ drbToAddList->list.count = ueCb->numDrb;
+ else
+ {
+ drbToAddList->list.count = 0;
+ for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
+ {
+ if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
+ drbToAddList->list.count++;
+ }
+ }
+ drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
+
+ CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
+ if(!drbToAddList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
+ return RFAILED;
+ }
+
+ drbIdx = 0;
+ for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
+ {
+ if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
+ continue;
+
+ CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
+ if(!drbToAddList->list.array[drbIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
+ return RFAILED;
+ }
+
+ /* DRB Id */
+ drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
+
+ /* PDCP Config */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
+ return RFAILED;
+ }
+
+ /* PDCP Config -> DRB */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
+ return RFAILED;
+ }
+
+ /* DRB -> Discard Timer */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
+ return RFAILED;
+ }
+ *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
+
+ /* UL PDCP SN length */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
+ return RFAILED;
+ }
+ *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
+
+ /* DL PDCP SN length */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
+ return RFAILED;
+ }
+ *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
+
+ /* Header Compression */
+ drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
+ drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
+
+ /* Reordering timer */
+ CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
+ if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
+ return RFAILED;
+ }
+ *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
+
+ drbIdx++;
+ }
+
+ return ROK;
+}
+
+/******************************************************************
+ *
+ * @brief Fill Radio bearer configuration
+ *
+ * @details
+ *
+ * Function : fillRadioBearerConfig
+ *
+ * Functionality: Fill Radio bearer configuration
+ *
+ * @params[in] UE control block
+ * Radio bearer config pointer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
+{
+ /* SRB To Add/Mod List */
+ CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
+ if(!radioBearerConfig->srb_ToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
+ return RFAILED;
+ }
+ if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
+ {
+ return RFAILED;
+ }
+
+ /* DRB To Add/Mod List */
+ CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
+ if(!radioBearerConfig->drb_ToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
+ return RFAILED;
+ }
+ if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
+ {
+ return RFAILED;
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill measurement object to add/mod list
+ *
+ * @details
+ *
+ * Function : fillMeasObjToAddModList
+ *
+ * Functionality: Fill measurement object to add/mod list
+ *
+ * @params[in] Measurement object to add/mod list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
+{
+ uint8_t elementCnt, objIdx;
+ MeasObjectNR_t *measObject;
+
+ elementCnt = 1;
+ measObjList->list.count = elementCnt;
+ measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
+
+ CU_ALLOC(measObjList->list.array, measObjList->list.size);
+ if(!measObjList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for measurement object list's array");
+ return RFAILED;
+ }
+
+ for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
+ {
+ CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
+ if(!measObjList->list.array[objIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for measurement object list's array element");
+ return RFAILED;
+ }
+ }
+
+ objIdx = 0;
+ measObjList->list.array[objIdx]->measObjectId = 1;
+ measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
+ CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
+ if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for mesurement object NR");
+ return RFAILED;
+ }
+
+ measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
+
+ /* SSB frequency */
+ CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
+ if(!measObject->ssbFrequency)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
+
+ /* Subcarrier spacing */
+ CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
+ if(!measObject->ssbSubcarrierSpacing)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
+
+ /* SMTC1 */
+ CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
+ if(!measObject->smtc1)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ measObject->smtc1->duration = SSB_MTC__duration_sf1;
+ measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
+ measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
+
+ /* Absoulute threshold SSB consolidation */
+ CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
+ if(!measObject->absThreshSS_BlocksConsolidation)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+
+ /* RSRP threshold */
+ CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
+ if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
+
+ /* RSRQ threshold */
+ CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
+ if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
+
+ /* SINR threshold */
+ CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
+ if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
+
+ /* Number of SSBs to average */
+ CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
+ if(!measObject->nrofSS_BlocksToAverage)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->nrofSS_BlocksToAverage) = 2;
+
+ /* Quantity Config index */
+ measObject->quantityConfigIndex = 1;
+
+ /* Offset MO */
+ /* RSRP offset for SSB */
+ CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
+ if(!measObject->offsetMO.rsrpOffsetSSB)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
+
+ /* RSRQ offset for SSB */
+ CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
+ if(!measObject->offsetMO.rsrpOffsetSSB)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
+
+ /* SINR offset for SSB */
+ CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
+ if(!measObject->offsetMO.sinrOffsetSSB)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+ *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill Report configuration to Add/mod list
+ *
+ * @details
+ *
+ * Function : fillReportCfgToAddModList
+ *
+ * Functionality: Fill Report configuration to Add/mod list
+ *
+ * @params[in] Report Config To Add/Mod List
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
+{
+ uint8_t elementCnt;
+ uint8_t reportCfgIdx;
+ ReportConfigToAddMod_t *reportCfg;
+ ReportConfigNR_t *reportCfgNr;
+ EventTriggerConfig_t *eventTriggCfg;
+
+ elementCnt = 1;
+ reportCfgList->list.count = elementCnt;
+ reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
+
+ CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
+ if(!reportCfgList->list.array)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
+ return RFAILED;
+ }
+
+ for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
+ {
+ CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
+ if(!reportCfgList->list.array[reportCfgIdx])
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
+ return RFAILED;
+ }
+ }
+
+ reportCfgIdx = 0;
+ reportCfg = reportCfgList->list.array[reportCfgIdx];
+ reportCfg->reportConfigId = 1;
+ reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
+
+ /* Report Configuration for NR */
+ CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
+ if(!reportCfg->reportConfig.choice.reportConfigNR)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
+ return RFAILED;
+ }
+ reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
+
+ /* Report Type */
+ reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
+ CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
+ if(!reportCfgNr->reportType.choice.eventTriggered)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
+ return RFAILED;
+ }
+ eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
+
+ /* Event 3 */
+ eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
+ CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
+ if(!eventTriggCfg->eventId.choice.eventA3)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
+ return RFAILED;
+ }
+
+ eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
+ eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
+ eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
+ eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
+ eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
+ eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
+
+ /* Reference Signal Type */
+ eventTriggCfg->rsType = NR_RS_Type_ssb;
+
+ /* Report Interval */
+ eventTriggCfg->reportInterval = ReportInterval_ms1024;
+
+ /* Report Amount */
+ eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
+
+ /* Report Quantity cell */
+ eventTriggCfg->reportQuantityCell.rsrp = true;
+ eventTriggCfg->reportQuantityCell.rsrq = false;
+ eventTriggCfg->reportQuantityCell.sinr = false;
+
+ /* Maximum reported cells */
+ eventTriggCfg->maxReportCells = 3;
+
+ /* Report qunatity RS Indexes */
+ CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
+ if(!eventTriggCfg->reportQuantityRS_Indexes)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
+ return RFAILED;
+ }
+ eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
+ eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
+ eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
+
+ /* Maximum number of RS indexes to report */
+ CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
+ if(!eventTriggCfg->maxNrofRS_IndexesToReport)
+ {
+ DU_LOG("\nERROR --> F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
+ return RFAILED;
+ }
+ *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
+
+ /* Include Beam measurement */
+ eventTriggCfg->includeBeamMeasurements = false;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill measurement Id to add/mod list
+
+ * @details
+ *
+ * Function : fillMeasIdToAddModList
+ *
+ * Functionality: Fill measurement Id to add/mod list
+ *
+ * @params[in] Measurement Id to add/mod list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
+{
+ uint8_t elementCnt;
+ uint8_t measIdIdx;
+
+ elementCnt = 1;
+ measIdList->list.count = elementCnt;
+ measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
+
+ CU_ALLOC(measIdList->list.array, measIdList->list.size);
+ if(!measIdList->list.array)
+ {
+ return RFAILED;
+ }
+
+ for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
+ {
+ CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
+ if(!measIdList->list.array[measIdIdx])
+ {
+ return RFAILED;
+ }
+
+ measIdIdx=0;
+ measIdList->list.array[measIdIdx]->measId = 1;
+ measIdList->list.array[measIdIdx]->measObjectId = 1;
+ measIdList->list.array[measIdIdx]->reportConfigId = 1;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill s-measurement configuration
+ *
+ * @details
+ *
+ * Function : fillSMeasConfig
+ *
+ * Functionality: Fill s-measurement configuration
+ *
+ * @params[in] s-Measurement config
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
+{
+ sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
+ sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill quantity config
+ *
+ * @details
+ *
+ * Function : fillQunatityConfig
+ *
+ * Functionality: Fill quantity config
+ *
+ * @params[in] Quantity Config
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
+{
+ uint8_t elementCnt = 0;
+ uint8_t quanCfgIdx = 0;
+ QuantityConfigNR_t *quantityCfgNr;
+
+ CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
+ if(!quantityCfg->quantityConfigNR_List)
+ {
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ quantityCfg->quantityConfigNR_List->list.count = elementCnt;
+ quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
+
+ CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
+ if(!quantityCfg->quantityConfigNR_List->list.array)
+ {
+ return RFAILED;
+ }
+
+ for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
+ {
+ CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
+ if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
+ {
+ return RFAILED;
+ }
+ }
+
+ quanCfgIdx = 0;
+ quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
+
+ /* Quantity Config of Reference signal */
+ CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
+
+ CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
+
+ CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
+
+ /* Quantity Config RS index */
+ CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
+ if(!quantityCfgNr->quantityConfigRS_Index)
+ {
+ return RFAILED;
+ }
+
+ CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
+
+ CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
+
+ CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
+ if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
+ {
+ return RFAILED;
+ }
+ *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill measurement configuration
+ *
+ * @details
+ *
+ * Function : fillMeasConfig
+ *
+ * Functionality: Fill measurement configuration
+ *
+ * @params[in] Measurement config
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
+{
+ /* Measurement object to add/mod list */
+ CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
+ if(!measConfig->measObjectToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillMeasObjToAddModList");
+ return RFAILED;
+ }
+
+ /* Report Config To add/mod list */
+ CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
+ if(!measConfig->reportConfigToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for report config list in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillReportCfgToAddModList");
+ return RFAILED;
+ }
+
+ /* Measurement Id to add/mod list */
+ CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
+ if(!measConfig->measIdToAddModList)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for measuerment id list in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillMeasIdToAddModList");
+ return RFAILED;
+ }
+
+ /* S-Measurement config */
+ CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
+ if(!measConfig->s_MeasureConfig)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for s measuerment config in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillSMeasConfig");
+ return RFAILED;
+ }
+
+ /* Qunatity Config */
+ CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
+ if(!measConfig->quantityConfig)
+ {
+ DU_LOG("\nERROR --> F1AP: Memory allocation failed for quantity config in fillMeasConfig");
+ return RFAILED;
+ }
+ if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP: Failure in fillQuantityConfig");
+ return RFAILED;
+ }
+
+return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill RRC reconfiguration non-critical extension IE
+ *
+ * @details
+ *
+ * Function : fillRrcReconfigNonCriticalExt
+ *
+ * Functionality: Fill RRC reconfiguration non-critical extension
+ *
+ * @params[in] RRC Reconfig Non-critical extension
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
+{
+ CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
+ if(!rrcRecfg->masterCellGroup)
+ {
+ return RFAILED;
+ }
+
+ if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
+ {
+ return RFAILED;
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill RRC reconfiguration structure
+ *
+ * @details
+ *
+ * Function : fillRrcReconfig
+ *
+ * Functionality: Fill RRC reconfiguration
+
+ *
+ * @params[in] UE Cb
+ * RRC reconfiguration structure
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
+{
+ memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
+
+ rrcReconfig->rrc_TransactionIdentifier = 1;
+ rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
+
+ CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
+ if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
+ {
+ DU_LOG("\nERROR --> F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
+ return RFAILED;
+ }
+
+ /* Radio Bearer Configuration */
+ CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
+ if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
+ return RFAILED;
+ }
+ if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to fill radio bearer config in fillRrcReconfig");
+ return RFAILED;
+ }
+
+ /* Measurement Configuration */
+ CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
+ if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
+ return RFAILED;
+ }
+ if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to fill measurement config in fillRrcReconfig");
+ return RFAILED;
+ }
+
+ /* Non Critical extension */
+ CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
+ if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
+ {
+ DU_LOG("\nERROR --> F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
+ return RFAILED;
+ }
+ if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to fill non critical extension in fillRrcReconfig");
+ return RFAILED;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill RRC reconfiguration Octet string
+ *
+ * @details
+ *
+ * Function : fillRrcReconfigBuf
+ *
+ * Functionality: Fill RRC reconfiguration octet string
+
+ *
+ * @params[in] OCTET_STRING_t buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t *rrcReconfigBuf, bool updateAllRbCfg)
+{
+ uint8_t ret = RFAILED;
+ asn_enc_rval_t encRetVal;
+ RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
+ rrcReconfig = &rrcRecfg;
+
+ while(true)
+ {
+ if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
+ break;
+ }
+
+ /* Encode RRC Reconfiguration */
+ xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ rrcReconfigBuf->size = encBufSize;
+ CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
+ if(!rrcReconfigBuf->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillRrcReconfigBuf");
+ break;
+ }
+ memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
+ ret = ROK;
+ break;
+ }
+
+ freeRrcReconfig(rrcReconfig);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill HO preparation information Octet string
+ *
+ * @details
+ *
+ * Function : fillHOPreparationInfoBuf
+ *
+ * Functionality: Fill HO preparation information Octet string
+
+ *
+ * @params[in] HandoverPreparationInformation_t buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
+{
+ uint8_t ret = RFAILED;
+ asn_enc_rval_t encRetVal;
+ HandoverPreparationInformationRrc_t hoPrepInfo;
+ HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
+
+ while(true)
+ {
+
+ hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
+ CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
+ if(!hoPrepInfo.criticalExtensions.choice.c1)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
+ break;
+ }
+ hoPrepInfo.criticalExtensions.choice.c1->present = \
+ HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
+
+ CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
+ sizeof(HandoverPreparationInformationRrc_IEs_t));
+ if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
+ break;
+ }
+ hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
+
+ /* Fill UE Capability RAT container list */
+ ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
+ if(ret != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to fill UE Capability RAT container list");
+ break;
+ }
+
+ /* Fill Source config */
+ hoPrepInfoIe->sourceConfig = NULLP;
+ CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
+ if(!hoPrepInfoIe->sourceConfig)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
+ return RFAILED;
+ }
+ ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
+
+ hoPrepInfoIe->rrm_Config = NULLP;
+ hoPrepInfoIe->as_Context = NULLP;
+ hoPrepInfoIe->nonCriticalExtension = NULLP;
+
+ /* encode UE Capability RAT Container List into duToCuRrcContainer */
+ xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
+ &hoPrepInfo, PrepFinalEncBuf, encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ }
+
+ hoPrepInfoBuf->size = encBufSize;
+ CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
+ if(!hoPrepInfoBuf->buf)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in fillUeCapabilityContainer");
+ break;
+ }
+ memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
+ ret = ROK;
+ break;
+ }
+ freeHOPreparationInfo(&hoPrepInfo);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills CuToDuContainer
+ *
+ * @details
+ *
+ * Function : fillCuToDuContainer
+ *
+ * Functionality: Fills CuToDuContainer
+ *
+ * @params[in] pointer to CUtoDURRCInformation_t
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
+{
+ uint8_t elementCnt = 0;
+ uint8_t ret = ROK;
+ uint8_t idx, idx2, rrcBufLen;
+
+ /* UE Capabulity RAT Container List */
+ CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
+ if(!rrcMsg->uE_CapabilityRAT_ContainerList)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for UE capability RAT container list failed");
+ return RFAILED;
+ }
+ ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
+
+ CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
+ if(!rrcMsg->measConfig)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for measurement configuration failed");
+ return RFAILED;
+ }
+ ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
+
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ {
+ /* IE extensions */
+ CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
+ if(rrcMsg->iE_Extensions)
+ {
+ elementCnt = 1;
+ rrcMsg->iE_Extensions->list.count = elementCnt;
+ rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
+
+ /* Initialize the CUtoDURRCInformation_ExtIEs */
+ CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
+
+ if(rrcMsg->iE_Extensions->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
+ ret = RFAILED;
+ }
+
+ for(idx=0; idx<elementCnt; idx++)
+ {
+ CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
+ if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation for array elements failed");
+ ret = RFAILED;
+ }
+ }
+
+ idx = 0;
+#if 0
+ /* Cell Group Configuration */
+ rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
+ rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
+ rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present =\
+ CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
+ ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
+ idx++;
+#endif
+ /* Handover Preparation Information */
+ rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
+ rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
+ rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present = \
+ CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
+ ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
+ }
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Free CuToDuContainer
+ *
+ * @details
+ *
+ * Function : FreeCuToDuInfo
+ *
+ * Functionality: Free CuToDuContainer
+ *
+ * @params[in] pointer to CUtoDURRCInformation_t
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+
+void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
+{
+ uint8_t idx, idx2;
+
+ if(rrcMsg->uE_CapabilityRAT_ContainerList)
+ {
+ if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
+ CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
+ CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
+ }
+ if(rrcMsg->iE_Extensions)
+ {
+ if(rrcMsg->iE_Extensions->list.array)
+ {
+ for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
+ {
+ if(rrcMsg->iE_Extensions->list.array[idx])
+ {
+ switch(rrcMsg->iE_Extensions->list.array[idx]->id)
+ {
+ case ProtocolIE_ID_id_CellGroupConfig:
+ if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
+ {
+ CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
+ rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
+
+ }
+ break;
+ default:
+ DU_LOG("\nERROR --> F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
+ rrcMsg->iE_Extensions->list.array[idx]->id);
+ break;
+ }
+ }
+ break;
+ }
+ for(idx2 = 0; idx2 < idx; idx2++)
+ {
+ CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
+ }
+ CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
+
+ }
+
+ CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
+ }
+}
+/*******************************************************************
+ *