+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
+ *
+ * @details
+ *
+ * Function : extractRlcCfgToAddMod
+ *
+ * Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
+ *
+ * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
+ * DuUeCfg Pointer
+ * @return ROK/RFAILED
+ *
+ * ****************************************************************/
+
+uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
+{
+ uint8_t idx, rbId, lcId, rlcMode, rbType;
+ RLC_Config_t *f1RlcCfg = NULLP;
+ LogicalChannelConfig_t *macUlLcCfg = NULLP;
+
+ for(idx = 0; idx < lcCfg->list.count; idx++)
+ {
+ lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
+ if(lcCfg->list.array[idx]->servedRadioBearer)
+ {
+ /* RadioBearer for SRB/DRB */
+ if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
+ RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
+ {
+ rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
+ rbType = RB_TYPE_SRB;
+ }
+ else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
+ RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
+ {
+ rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
+ rbType = RB_TYPE_DRB;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> No components present in Bearer config to ADD/MOD");
+ return RFAILED;
+ }
+ /* MAC UL LC Config */
+ if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
+ {
+ macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DUAPP: Received RadioBearer config is NULL");
+ return RFAILED;
+ }
+ /* RLC Mode Config */
+ if(lcCfg->list.array[idx]->rlc_Config)
+ {
+ rlcMode = lcCfg->list.array[idx]->rlc_Config->present;
+ f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
+ }
+
+ /* Filling RLC/MAC Config*/
+ memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
+ memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
+ procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
+ if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
+ {
+ DU_LOG("\nERROR --> DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
+ return RFAILED;
+ }
+ (ueCfgDb->numRlcLcs)++;
+ (ueCfgDb->numMacLcs)++;
+ }
+ //TODO: To send the failure cause in UeContextSetupRsp
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief DeAlloc pdsch serv cell config info
+ *
+ * @details
+ *
+ * Function : freeMacPdschServCellInfo
+ *
+ * Functionality: DeAlloc pdsch serv cell config info
+ *
+ * @params[in] PdschServCellCfg pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
+{
+ if(pdsch->xOverhead)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(uint8_t));
+ }
+ if(pdsch->codeBlkGrpFlushInd)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
+ }
+ if(pdsch->maxCodeBlkGrpPerTb)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(uint8_t));
+ }
+ if(pdsch->maxMimoLayers)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Free Serving cell Info
+ *
+ * @details
+ *
+ * Function : freeMacServingCellInfo
+ *
+ * Functionality: Free Serving cell Info
+ *
+ * @params[in] ServCellCfgInfo *srvCellCfg
+ * @return void
+ *
+ * ****************************************************************/
+void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
+{
+ freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
+ if(srvCellCfg->bwpInactivityTmr)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Free cell Grp Cfg Info
+ *
+ * @details
+ *
+ * Function : freeUeReCfgCellGrpInfo
+ *
+ * Functionality: Free cell Grp Cfg Info
+ *
+ * @params[in] MacUeCfg* duUeCfg
+ * @return void
+ *
+ * ****************************************************************/
+
+void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
+{
+ freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
+}
+
+/*******************************************************************
+ *
+ * @brief Fills Reconfig SchReqReConfig
+ *
+ * @details
+ *
+ * Function : extractSchReqReConfig
+ *
+ * Functionality: Fills Reconfig SchReqReConfig
+ *
+ * @params[in] SchedulingRequestConfig_t *cuSchedReq
+ * SchedReqCfg* macSchedReq
+ * @return void
+ *
+ * ****************************************************************/
+void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
+{
+ uint8_t schReqIdx = 0;
+ struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
+ struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
+
+ if(cuSchedReq->schedulingRequestToAddModList)
+ {
+ schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
+ if(schReqListToAdd->list.count)
+ {
+ macSchedReq->addModListCount = schReqListToAdd->list.count;
+ for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
+ {
+ macSchedReq->addModList[schReqIdx].schedReqId = \
+ schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
+ macSchedReq->addModList[schReqIdx].srProhibitTmr = \
+ *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
+ macSchedReq->addModList[schReqIdx].srTransMax =\
+ schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
+ }
+ }
+ }
+ /* Scheduling Req To release */
+ if(cuSchedReq->schedulingRequestToReleaseList)
+ {
+ schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
+ if(schReqListToRel->list.count)
+ {
+ macSchedReq->relListCount = schReqListToRel->list.count;
+ for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
+ {
+ macSchedReq->relList[schReqIdx] = \
+ *schReqListToRel->list.array[schReqIdx];
+ }
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fills TagReconfig
+ *
+ * @details
+ *
+ * Function : extractTagReconfig
+ *
+ * Functionality: Fills extractTagReconfig
+ *
+ * @params[in] TAG_Config_t *cuTagCfg
+ * TagCfg *macTagCfg
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
+{
+ uint8_t tagIdx = 0;
+ struct TAG_Config__tag_ToAddModList *tagListToAddMod = NULLP;
+ struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
+
+ /* Tag config to AddMod */
+ if(cuTagCfg->tag_ToAddModList)
+ {
+ tagListToAddMod = cuTagCfg->tag_ToAddModList;
+ if(tagListToAddMod->list.count)
+ {
+ macTagCfg->addModListCount = tagListToAddMod->list.count;
+ for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
+ {
+ macTagCfg->addModList[tagIdx].tagId =\
+ tagListToAddMod->list.array[tagIdx]->tag_Id;
+ macTagCfg->addModList[tagIdx].timeAlignTimer = \
+
+ tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
+ }
+ }
+ }
+ /* Tag config to release */
+ if(cuTagCfg->tag_ToReleaseList)
+ {
+ tagListToRel = cuTagCfg->tag_ToReleaseList;
+ if(tagListToRel->list.count)
+ {
+ macTagCfg->relListCount = tagListToRel->list.count;
+ for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
+ {
+ macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
+ }
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fills PdcchCfg received by CU
+ *
+ * @details
+ *
+ * Function : extractPdcchCfg
+ *
+ * Functionality: Fills PdcchCfg received by CU
+ *
+ * @params[in] PDCCH_Config_t *cuPdcchCfg,
+ * PdcchConfig *duPdcchCfg
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
+{
+ uint8_t cRsetIdx = 0;
+ uint8_t srchSpcIdx = 0;
+
+ struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
+ struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
+ struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
+ struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
+
+
+ /* Control Resource Set To Add/Mod List */
+ if(cuPdcchCfg->controlResourceSetToAddModList)
+ {
+ cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
+ if(cRsetToAddModList->list.count)
+ {
+ macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
+ for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
+ {
+ macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
+ cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
+ bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
+ macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
+ macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
+ cRsetToAddModList->list.array[cRsetIdx]->duration;
+
+ macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
+ cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
+ if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
+ {
+ //TODO: handle the case for Interleaved
+ }
+ macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
+ cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
+ if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
+ {
+ macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
+ *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
+ }
+ }
+ }
+
+ }
+ /* Control Resource Set To Release List */
+ if(cuPdcchCfg->controlResourceSetToReleaseList)
+ {
+ cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
+ if(cRsetToRelList->list.count)
+ {
+ macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
+ for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
+ {
+ macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
+ }
+ }
+ }
+
+ /* Search space To Add/Mod List */
+ if(cuPdcchCfg->searchSpacesToAddModList)
+ {
+ srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
+ if(srchSpcToAddModList->list.count)
+ {
+ macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
+ for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
+ {
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
+ srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
+ *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
+ if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
+ {
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
+ srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
+ }
+ if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
+ {
+ bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
+ }
+ if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
+ {
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
+ srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
+ srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
+ srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
+
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
+ srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
+
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
+ srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
+ }
+ if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
+ {
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
+ srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
+ if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
+ {
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
+ srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
+ }
+
+ }
+ }
+ }
+ }
+ /* Search space To Rel List */
+ if(cuPdcchCfg->searchSpacesToReleaseList)
+ {
+ srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
+ if(srchSpcToRelList->list.count)
+ {
+ macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
+ for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
+ {
+ macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
+ *(srchSpcToRelList->list.array[srchSpcIdx]);
+ }
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fills PdschCfg received by CU
+ *
+ * @details
+ *
+ * Function : extractPdschCfg
+ *
+ * Functionality: Fills PdschCfg received by CU
+ *
+ * @params[in] PDSCH_Config_t *cuPdschCfg,
+ * PdschConfig *macPdschCfg
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
+{
+ uint8_t timeDomIdx;
+ struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
+
+ if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
+ {
+ if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
+ PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
+ {
+ if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
+ {
+ macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
+ *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
+ }
+ }
+ }
+ macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
+ if(cuPdschCfg->pdsch_TimeDomainAllocationList)
+ {
+ timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
+ if(timeDomAlloc->present ==\
+ PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
+ {
+ if(timeDomAlloc->choice.setup)
+ {
+ macPdschCfg->numTimeDomRsrcAlloc = timeDomAlloc->choice.setup->list.count;
+ for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
+ {
+ macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
+ timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
+ macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
+ timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
+ }
+ }
+ }
+ }
+ macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
+ if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
+ macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
+ if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
+ {
+ macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
+ if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
+ {
+ if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
+ {
+ macPdschCfg->bundlingInfo.StaticBundling.size = \
+ *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
+ }
+ }
+ }
+ else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
+ {
+ macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
+ }
+
+}
+
+/*******************************************************************
+ *
+ * @brief Fills PdschServingCellCfg received by CU
+ *
+ * @details
+ *
+ * Function : extractPdschServingCellCfg
+ *
+ * Functionality: Fills PdschCfg received by CU
+ *
+ * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
+ * PdschServCellCfg *macUePdschSrvCellCfg
+ * @return ROK/RFAILED
+ *
+ * ****************************************************************/
+
+uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
+{
+ if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
+ {
+ if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
+ {
+ if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
+ {
+ *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb) = \
+ cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
+ }
+ else
+ {
+ DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(uint8_t));
+ if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
+ {
+ *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb) = \
+ cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
+ return RFAILED;
+ }
+ }
+ if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
+ {
+ *(macUePdschSrvCellCfg->codeBlkGrpFlushInd) = \
+ cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
+ }
+ else
+ {
+ DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(bool));
+ if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
+ {
+ *(macUePdschSrvCellCfg->codeBlkGrpFlushInd) = \
+ cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
+ return RFAILED;
+ }
+ }
+ }
+ }
+ if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
+ {
+ macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
+ }
+ if(cuPdschSrvCellCfg->ext1)
+ {
+ if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
+ {
+ if(macUePdschSrvCellCfg->maxMimoLayers)
+ {
+ *(macUePdschSrvCellCfg->maxMimoLayers) = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
+ }
+ else
+ {
+ DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
+ if(macUePdschSrvCellCfg->maxMimoLayers)
+ {
+ *(macUePdschSrvCellCfg->maxMimoLayers) = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
+ return RFAILED;
+ }
+ }
+ }
+ }
+ if(cuPdschSrvCellCfg->xOverhead)
+ {
+ if(macUePdschSrvCellCfg->xOverhead)
+ {
+ *(macUePdschSrvCellCfg->xOverhead) = *(cuPdschSrvCellCfg->xOverhead);
+ }
+ else
+ {
+ DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(uint8_t));
+ if(macUePdschSrvCellCfg->xOverhead)
+ {
+ *(macUePdschSrvCellCfg->xOverhead) = *(cuPdschSrvCellCfg->xOverhead);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
+ return RFAILED;
+ }
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills PuschCfg received by CU
+ *
+ * @details
+ *
+ * Function : extractPuschCfg
+ *
+ * Functionality: Fills PuschCfg received by CU
+ *
+ * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
+ * PuschCfg *macPuschCfg
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
+{
+ uint8_t timeDomIdx = 0;
+ DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
+ struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
+
+ if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
+ {
+ if(cuPuschCfg->choice.setup)
+ {
+ if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
+ {
+ macPuschCfg->dataScramblingId = \
+ *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
+ }
+ if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
+ {
+ if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
+ {
+ if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
+ {
+ dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
+ if(dmrsUlCfg->dmrs_AdditionalPosition)
+ {
+ macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
+ *(dmrsUlCfg->dmrs_AdditionalPosition);
+ }
+ if(dmrsUlCfg->transformPrecodingDisabled)
+ {
+ if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
+ {
+ macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
+ *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
+ }
+ }
+ }
+ }
+ }
+ /*Res Alloc Type for UL */
+ if(cuPuschCfg->choice.setup->resourceAllocation)
+ {
+ macPuschCfg->resourceAllocType = \
+ cuPuschCfg->choice.setup->resourceAllocation;
+ }
+ if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
+ {
+ timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
+ if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
+ {
+ if(timeDomAllocList->choice.setup)
+ {
+ macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
+ for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
+ {
+ macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
+ *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
+ macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
+ timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
+ macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
+ timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
+ }
+ }
+ }
+ }
+ if(cuPuschCfg->choice.setup->transformPrecoder)
+ macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Function to fill pucch Power Control
+ *
+ * @details
+ *
+ * Function : extractPucchPowerControl
+ *
+ * Functionality: Function to fill pucch Power Control
+ *
+ * @params[in] PucchPowerControl *pwrCtrl,
+ * struct PUCCH_PowerControl *cuPwrCtrlCfg
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
+{
+ uint8_t arrIdx;
+
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
+ pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
+ pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
+ pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
+ pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
+ pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
+ if(cuPwrCtrlCfg->p0_Set)
+ {
+ pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
+ for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
+ {
+ pwrCtrl->p0Set[arrIdx].p0PucchId =\
+ cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
+ pwrCtrl->p0Set[arrIdx].p0PucchVal =\
+ cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
+ }
+ }
+ if(cuPwrCtrlCfg->pathlossReferenceRSs)
+ {
+ pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
+ for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
+ {
+ pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
+ cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
+ }
+ }
+}
+
+ /*******************************************************************
+ *
+ * @brief Function to extractResrcSetToAddModList sent by CU
+ *
+ * @details
+ *
+ * Function : extractResrcSetToAddModList
+ *
+ * Functionality: Fucntion to extractResrcSetToAddModList
+ *
+ * @params[in] PucchResrcSetCfg pointer,
+ * struct PUCCH_Config__resourceSetToAddModList pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
+{
+ uint8_t arrIdx, rsrcListIdx;
+
+ macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
+ for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
+ {
+ macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId =\
+ cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
+ macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
+ cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
+ for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
+ {
+ macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
+ *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
+ }
+ macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
+ *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
+ }
+}/* End of extractResrcSetToAddModList */
+
+/*******************************************************************
+ *
+ * @brief Fills extractResrcToAddModList sent by CU
+ *
+ * @details
+ *
+ * Function : extractResrcToAddModList
+ *
+ * Functionality: Fills extractResrcToAddModList
+ *
+ * @params[in] PucchResrcCfg pointer,
+ * struct PUCCH_Config__resourceToAddModList pointer
+ * @return ROk/RFAILED
+ *
+ * ****************************************************************/
+
+uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
+{
+ uint8_t arrIdx;
+
+ macResrcList->resrcToAddModListCount = cuResrcList->list.count;
+ for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
+ {
+ macResrcList->resrcToAddModList[arrIdx].resrcId =\
+ cuResrcList->list.array[arrIdx]->pucch_ResourceId;
+ macResrcList->resrcToAddModList[arrIdx].startPrb =\
+ cuResrcList->list.array[arrIdx]->startingPRB;
+ if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
+ {
+ macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
+ *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
+ }
+ if(cuResrcList->list.array[arrIdx]->secondHopPRB)
+ {
+ macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
+ *cuResrcList->list.array[arrIdx]->secondHopPRB;
+ }
+ /* PUCCH RSRC FORMAT */
+ if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format0)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
+ cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
+ }
+ }
+ else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format1)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
+ cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
+ cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
+ }
+ }
+ else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format2)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
+ cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
+ }
+ }
+ else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format3)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
+ cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
+ }
+ }
+ else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format4)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
+ cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
+ }
+ }
+ }
+ return ROK;
+
+}/* End of extractResrcToAddModList */
+
+/*******************************************************************
+ *
+ * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
+ *
+ * @details
+ *
+ * Function : fillPucchSchedReqPeriodAndOffset
+ *
+ * Functionality: To fillPucchSchedReqPeriodAndOffset
+ *
+ * @params[in] macPeriodicty,
+ * SchedulingRequestResourceConfig__periodicityAndOffset pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t macOffset,\
+ struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
+{
+ macPeriodicty = cuPeriodicty->present;
+ switch(macPeriodicty)
+ {
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
+ {
+ macOffset = cuPeriodicty->choice.sym2;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
+ {
+ macOffset = cuPeriodicty->choice.sym6or7;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
+ {
+ macOffset = cuPeriodicty->choice.sl1;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
+ {
+ macOffset = cuPeriodicty->choice.sl2;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
+ {
+ macOffset = cuPeriodicty->choice.sl4;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
+ {
+ macOffset = cuPeriodicty->choice.sl5;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
+ {
+ macOffset = cuPeriodicty->choice.sl8;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
+ {
+ macOffset = cuPeriodicty->choice.sl10;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
+ {
+ macOffset = cuPeriodicty->choice.sl16;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
+ {
+ macOffset = cuPeriodicty->choice.sl20;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
+ {
+ macOffset = cuPeriodicty->choice.sl40;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
+ {
+ macOffset = cuPeriodicty->choice.sl80;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
+ {
+ macOffset = cuPeriodicty->choice.sl160;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
+ {
+ macOffset = cuPeriodicty->choice.sl320;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
+ {
+ macOffset = cuPeriodicty->choice.sl640;
+ break;
+ }
+ default :
+ DU_LOG("\nERROR --> F1AP : Invalid periodicity %d", macPeriodicty);
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Function to extractPucchFormatCfg sent by CU
+ *
+ * @details
+ *
+ * Function : extractPucchFormatCfg
+ *
+ * Functionality: Function to extractPucchFormatCfg
+ *
+ * @params[in] PucchFormatCfg pointer,
+ * PUCCH_FormatConfig_t pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
+ {
+ if(cuFormatCfg->interslotFrequencyHopping)
+ macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
+ if(cuFormatCfg->additionalDMRS)
+ macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
+ if(cuFormatCfg->maxCodeRate)
+ macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
+ if(cuFormatCfg->nrofSlots)
+ macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
+ if(cuFormatCfg->pi2BPSK)
+ macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
+ if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
+ macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
+ }/* End of extractPucchFormatCfg */
+
+/*******************************************************************
+ *
+ * @brief Function to extractSchedReqCfgToAddMod sent by CU
+ *
+ * @details
+ *
+ * Function : extractSchedReqCfgToAddMod
+ *
+ * Functionality: Function to extractSchedReqCfgToAddMod
+ *
+ * @params[in] PucchSchedReqCfg pointer,
+ * PUCCH_Config__schedulingRequestResourceToAddModList pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
+{
+ uint8_t arrIdx;
+
+ macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
+ for(arrIdx = 0; arrIdx < macSchedReqCfg->schedAddModListCount; arrIdx++)
+ {
+ macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
+ cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
+ macSchedReqCfg->schedAddModList[arrIdx].requestId =\
+ cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
+ if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
+ {
+ fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
+ macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
+ }
+ if(cuSchedReqList->list.array[arrIdx]->resource)
+ {
+ macSchedReqCfg->schedAddModList[arrIdx].resrc =\
+ *cuSchedReqList->list.array[arrIdx]->resource;
+ }
+ }
+
+}/* End of extractSchedReqCfgToAddMod */
+
+ /*******************************************************************
+ *
+ * @brief Fills PucchCfg received by CU
+ *
+ * @details
+ *
+ * Function : extractPucchCfg
+ *
+ * Functionality: Fills PucchCfg received by CU
+ *
+ * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
+ * PucchCfg *macPucchCfg
+ * @return ROK/RFAILED
+ *
+ * ****************************************************************/
+
+uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
+{
+ uint8_t arrIdx;
+
+ if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
+ {
+ if(cuPucchCfg->choice.setup)
+ {
+ /* Resource Set Cfg */
+ if(cuPucchCfg->choice.setup->resourceSetToAddModList)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
+ if(macPucchCfg->resrcSet == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
+ extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
+ }
+
+ /* Resource Cfg */
+ if(cuPucchCfg->choice.setup->resourceToAddModList)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
+ if(macPucchCfg->resrc == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
+ extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
+ }
+
+ /* Format 1 Cfg */
+ if(cuPucchCfg->choice.setup->format1)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
+ if(macPucchCfg->format1 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
+ extractPucchFormatCfg(macPucchCfg->format1,\
+ cuPucchCfg->choice.setup->format1->choice.setup);
+ }
+
+ /* Format 2 Cfg */
+ if(cuPucchCfg->choice.setup->format2)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
+ if(macPucchCfg->format2 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
+ extractPucchFormatCfg(macPucchCfg->format2,\
+ cuPucchCfg->choice.setup->format2->choice.setup);
+ }
+
+ /* Format 3 Cfg */
+ if(cuPucchCfg->choice.setup->format3)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
+ if(macPucchCfg->format3 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
+ extractPucchFormatCfg(macPucchCfg->format3,\
+ cuPucchCfg->choice.setup->format3->choice.setup);
+ }
+
+ /* Format 4 Cfg */
+ if(cuPucchCfg->choice.setup->format4)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
+ if(macPucchCfg->format4 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
+ extractPucchFormatCfg(macPucchCfg->format4,\
+ cuPucchCfg->choice.setup->format4->choice.setup);
+ }
+
+ /* Sched Req List */
+ if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
+ if(macPucchCfg->schedReq == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
+ extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
+ cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
+ }
+
+ /*TODO: Add support for Spatial Info */
+
+ /* MultiCsiCfg */
+ if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
+ if(macPucchCfg->multiCsiCfg == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
+ macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
+ for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
+ {
+ macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
+ *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
+ }
+ }
+
+ /* Dl_DataToUL_ACK */
+ if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
+ if(macPucchCfg->dlDataToUlAck == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
+ macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
+ for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
+ {
+ macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
+ *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
+ }
+ }
+
+ /* Power Control */
+ if(cuPucchCfg->choice.setup->pucch_PowerControl)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
+ if(macPucchCfg->powerControl == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
+ return RFAILED;
+ }
+ extractPucchPowerControl(macPucchCfg->powerControl,\
+ cuPucchCfg->choice.setup->pucch_PowerControl);
+ }
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills ServingCellReconfig received by CU
+ *
+ * @details
+ *
+ * Function : extractSpCellDedicatedCfg
+ *
+ * Functionality: Fills ServingCellReconfig received by CU
+ *
+ * @params[in] ServingCellConfig_t *cuSrvCellCfg
+ * ServCellCfgInfo *macSrvCellCfg
+ * @return ROK/RFAILD
+ *
+ * ****************************************************************/
+uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
+{
+ uint8_t ret = ROK;
+ BWP_DownlinkDedicated_t *dlBwp = NULLP;
+ BWP_UplinkDedicated_t *ulBwp = NULLP;
+
+ if(cuSrvCellCfg->initialDownlinkBWP)
+ {
+ dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
+ if(dlBwp->pdcch_Config)
+ {
+ if(dlBwp->pdcch_Config->choice.setup)
+ {
+ macSrvCellCfg->initDlBwp.pdcchPresent = true;
+ extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
+ }
+ }
+ if(dlBwp->pdsch_Config)
+ {
+ if(dlBwp->pdsch_Config->choice.setup)
+ {
+ macSrvCellCfg->initDlBwp.pdschPresent = true;
+ extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
+ }
+ }
+ }
+ if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
+ macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
+ if(cuSrvCellCfg->defaultDownlinkBWP_Id)
+ macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
+ if(cuSrvCellCfg->bwp_InactivityTimer)
+ {
+ if(macSrvCellCfg->bwpInactivityTmr)
+ {
+ memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
+ }
+ else
+ {
+ macSrvCellCfg->bwpInactivityTmr = NULLP;
+ DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
+ if(macSrvCellCfg->bwpInactivityTmr)
+ {
+ memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
+ }
+ else
+ {
+ DU_LOG("\nERROR --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
+ return RFAILED;
+ }
+ }
+ }
+ if(cuSrvCellCfg->pdsch_ServingCellConfig)
+ {
+ if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
+ {
+ ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
+ return RFAILED;
+ }
+ }
+ }
+ if(cuSrvCellCfg->uplinkConfig)
+ {
+ if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
+ {
+ ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
+ if(ulBwp->pusch_Config)
+ {
+ macSrvCellCfg->initUlBwp.puschPresent = true;
+ extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
+ }
+ if(ulBwp->pucch_Config)
+ {
+ macSrvCellCfg->initUlBwp.pucchPresent = true;
+ memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
+ extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
+ }
+ }
+ if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
+ macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
+ }
+ return ret;
+}
+/*******************************************************************
+ *
+ * @brief Fills Reconfig Cell group Info received by CU
+ *
+ * @details
+ *
+ * Function : extractUeReCfgCellInfo
+ *
+ * Functionality: Fills Reconfig Cell group Info received by CU
+ *
+ * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
+ * MacUeCfg* macUeCfg
+ * @return ROK/RFAILED
+ *
+ * ****************************************************************/
+uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
+{
+ uint8_t ret = ROK;
+ MAC_CellGroupConfig_t *macCellGroup = NULLP;
+ PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
+ SpCellConfig_t *spcellCfg = NULLP;
+ ServingCellConfig_t *servCellCfg = NULLP;
+
+ if(cellGrp)
+ {
+ /* Fill MacCell Group Reconfig */
+ if(cellGrp->mac_CellGroupConfig)
+ {
+ macUeCfg->macCellGrpCfgPres = true;
+ macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
+ if(macCellGroup->schedulingRequestConfig)
+ {
+ extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
+ }
+ if(macCellGroup->tag_Config)
+ {
+ extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
+ }
+ if(macCellGroup->bsr_Config)
+ {
+ macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
+ macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer = macCellGroup->bsr_Config->retxBSR_Timer;
+ if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
+ {
+ macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer =\
+ *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
+ }
+ }
+ if(macCellGroup->phr_Config)
+ {
+ if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
+ {
+ macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
+ if(macCellGroup->phr_Config->choice.setup)
+ {
+ macUeCfg->macCellGrpCfg.phrCfg.periodicTimer = \
+ macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
+ macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer = \
+ macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
+ macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor = \
+ macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
+ macUeCfg->macCellGrpCfg.phrCfg.multiplePHR = \
+ macCellGroup->phr_Config->choice.setup->multiplePHR;
+ macUeCfg->macCellGrpCfg.phrCfg.dummy = \
+ macCellGroup->phr_Config->choice.setup->dummy;
+ macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
+ macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
+ macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG = \
+ macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
+ }
+ }
+ }
+ }
+ /* Fill Physical Cell Group Reconfig */
+ if(cellGrp->physicalCellGroupConfig)
+ {
+ macUeCfg->phyCellGrpCfgPres = true;
+ phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
+ if(phyCellGrpCfg->p_NR_FR1)
+ {
+ if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
+ macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
+ }
+ macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
+ }
+ /* Fill SpCell Reconfig */
+ if(cellGrp->spCellConfig)
+ {
+ macUeCfg->spCellCfgPres = true;
+ spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
+ if(spcellCfg->servCellIndex)
+ {
+ macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
+ }
+ /* Fill Serving cell Reconfig info */
+ if(cellGrp->spCellConfig->spCellConfigDedicated)
+ {
+ servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
+ ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
+ }
+ }
+ }
+ }
+ return ret;
+}
+/*******************************************************************
+*
+* @brief free the memory allocated by decoder
+*
+* @details
+*
+* Function : freeAperDecodeNrcgi
+*
+* Functionality: Free Nrcgi values
+*
+* @params[in] NRCGI_t *nrcgi
+* @return void
+*
+* ****************************************************************/
+
+
+void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
+{
+ if(nrcgi->pLMN_Identity.buf != NULLP)
+ {
+ free(nrcgi->pLMN_Identity.buf);
+ }
+ if(nrcgi->nRCellIdentity.buf != NULLP)
+ {
+ free(nrcgi->nRCellIdentity.buf);
+ }
+}
+/*******************************************************************
+*
+* @brief free the memory allocated by decoder
+*
+* @details
+*
+* Function : freeAperDecodeCuToDuInfo
+*
+* Functionality: Free Cu To Du Information
+*
+* @params[in] CUtoDURRCInformation_t *rrcMsg
+* @return void
+*
+* ****************************************************************/
+
+
+void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
+{
+ uint8_t ieIdx =0;
+ uint8_t arrIdx =0;
+
+ if(rrcMsg->uE_CapabilityRAT_ContainerList)
+ {
+ if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
+ free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
+ free(rrcMsg->uE_CapabilityRAT_ContainerList);
+ }
+
+ if(rrcMsg->iE_Extensions)
+ {
+ if(rrcMsg->iE_Extensions->list.array)
+ {
+ for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
+ {
+ if(rrcMsg->iE_Extensions->list.array[ieIdx])
+ {
+ switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_CellGroupConfig:
+ if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
+ {
+ free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
+ }
+ break;
+ default:
+ DU_LOG("\nERROR --> F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
+ rrcMsg->iE_Extensions->list.array[ieIdx]->id);
+ break;
+ }
+ }
+ }
+ for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
+ {
+ free(rrcMsg->iE_Extensions->list.array[arrIdx]);
+ }
+ free(rrcMsg->iE_Extensions->list.array);
+
+ }
+
+ free(rrcMsg->iE_Extensions);
+ }
+}
+/*******************************************************************
+*
+* @brief free the memory allocated by decoder
+*
+* @details
+*
+* Function : freeAperDecodeSplCellList
+*
+* Functionality: Free Spl Cell List
+ where memory allocated by aper_decoder
+*
+* @params[in] SCell_ToBeSetup_List_t *spCellLst
+* @return void
+*
+* ****************************************************************/
+
+
+void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
+{
+ uint8_t cellIdx =0;
+
+ if(spCellLst->list.array != NULLP)
+ {
+ for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
+ {
+ if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
+ {
+ freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
+ }
+ if(spCellLst->list.array[cellIdx]!=NULLP)
+ {
+ free(spCellLst->list.array[cellIdx]);
+ }
+ }
+ free(spCellLst->list.array);
+ }
+}
+/*******************************************************************
+*
+* @brief free the memory allocated by decoder
+*
+* @details
+*
+* Function : freeAperDecodeSRBSetup
+*
+* Functionality: added free part for the memory allocated by aper_decoder
+*
+* @params[in] SRBs_ToBeSetup_List_t *srbSet
+* @return void
+*
+****************************************************************/
+
+
+void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
+{
+ uint8_t srbIdx =0;
+ if(srbSet->list.array != NULLP)
+ {
+ for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
+ {
+ if(srbSet->list.array[srbIdx]!=NULLP)
+ {
+ free(srbSet->list.array[srbIdx]);
+ }
+ }
+ free(srbSet->list.array);
+ }
+}
+
+/*******************************************************************
+*
+* @brief free the memory allocated by decoder
+*
+* @details
+*
+* Function : freeAperDecodeULTnlInfo
+*
+* Functionality: added free part for the memory allocated by aper_decoder
+*
+* @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
+* @return void
+*
+* ****************************************************************/
+
+
+void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
+{
+ uint8_t ulIdx=0;
+ if(ulInfo->list.array != NULLP)
+ {
+ for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
+ {
+ if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
+ {
+ if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
+ {
+ if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
+ transportLayerAddress.buf != NULLP)
+ {
+ if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
+ !=NULLP)
+ {
+ free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
+ }
+ free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
+ transportLayerAddress.buf);
+ }
+ free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
+ }
+ }
+ if(ulInfo->list.array[ulIdx]!=NULLP)
+ {
+ free(ulInfo->list.array[ulIdx]);
+ }
+ }
+ free(ulInfo->list.array);
+ }
+}
+/*******************************************************************
+*
+* @brief free the memory allocated by decoder
+*
+* @details
+*
+* Function : freeAperDecodeDRBSetup
+*
+* Functionality: free DRBSetup which is allocated by decoder
+*
+* @params[in] DRBs_ToBeSetup_List_t *drbSet
+* @return void
+*
+* ****************************************************************/
+
+void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
+{
+ DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
+ uint8_t flowIdx =0;
+ uint8_t drbIdx =0;
+
+ if(drbSet->list.array != NULLP)
+ {
+ for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
+ {
+ if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
+ {
+ drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
+ if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
+ {
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
+ qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
+ {
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
+ qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
+ {
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
+ qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
+ {
+
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
+ {
+
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
+ {
+
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
+ buf!=NULLP)
+ {
+
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
+ flows_Mapped_To_DRB_List.list.array != NULLP)
+ {
+
+ for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
+ {
+
+ if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
+ {
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
+ qoSFlowLevelQoSParameters.\
+ qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
+ {
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
+ qoSFlowLevelQoSParameters.\
+ qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
+ {
+
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
+ qoSFlowLevelQoSParameters.\
+ qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
+ {
+
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
+ qoSFlowLevelQoSParameters.\
+ qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
+ }
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
+ qoSFlowLevelQoSParameters.\
+ qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
+ }
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+
+ DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
+ qoSFlowLevelQoSParameters.\
+ qoS_Characteristics.choice.non_Dynamic_5QI);
+ }
+ }
+ if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
+ {
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
+ }
+ }
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.flows_Mapped_To_DRB_List.list.array);
+ }
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
+ DRB_Information.sNSSAI.sD->buf);
+ }
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
+ }
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
+
+ }
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
+
+ qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
+ }
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
+ qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
+ }
+
+ free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
+ qoS_Characteristics.choice.non_Dynamic_5QI);
+ }
+ free(drbSetItem->qoSInformation.choice.choice_extension);
+ }
+ freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
+ if(drbSetItem->uLConfiguration)
+ {
+ free(drbSetItem->uLConfiguration);
+ }
+ }
+ if(drbSet->list.array[drbIdx]!=NULLP)
+ {
+ free(drbSet->list.array[drbIdx]);
+ }
+ }
+ free(drbSet->list.array);
+ }
+}
+
+
+/*******************************************************************
+ *
+ * @brief builds Mac Cell Cfg
+ *
+ * @details
+ *
+ * Function : procUeReCfgCellInfo
+ *
+ * Functionality: builds Mac Cell Cfg
+ *
+ * @params[in] MacUeCfg pointer
+ * void pointer
+ *
+ * @return void
+ *
+ * ****************************************************************/
+uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
+{
+ uint8_t ret = ROK;
+ CellGroupConfigRrc_t *cellGrp = NULLP;
+
+ if(cellInfo)
+ {
+ cellGrp = (CellGroupConfigRrc_t *)cellInfo;
+ ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
+ if(ret == RFAILED)
+ DU_LOG("\nERROR --> F1AP : Failed at procUeReCfgCellInfo()");
+ }
+ if(ret == RFAILED)
+ {
+ freeUeReCfgCellGrpInfo(macUeCfg);
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Filling modulation info in mac ue cfg
+ *
+ * @details
+ *
+ * Function : duFillModulationDetails
+ *
+ * Functionality: Filling modulation info in mac ue cfg
+ *
+ * @params[in] MAC UE Config to be updated
+ * Current UE configuration
+ * UE NR capability from CU
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
+{
+ UE_NR_Capability_t *ueNrCap;
+
+ if(ueCap)
+ ueNrCap = (UE_NR_Capability_t *)ueCap;
+
+ /* Filling DL modulation info */
+ if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
+ ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
+ ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
+ {
+ switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
+ {
+ case ModulationOrder_qpsk:
+ {
+ ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
+ break;
+ }
+ case ModulationOrder_qam16:
+ {
+ ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
+ break;
+ }
+ case ModulationOrder_qam64:
+ {
+ ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
+ ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
+ ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
+ break;
+ }
+ case ModulationOrder_qam256:
+ {
+ ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
+ memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
+ break;
+ }
+ }
+ }
+ else
+ {
+ memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
+ }
+
+ /* Filling UL modulation info */
+ if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
+ ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
+ ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
+ {
+ switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
+ {
+ case ModulationOrder_qpsk:
+ {
+ ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
+ break;
+ }
+ case ModulationOrder_qam16:
+ {
+ ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
+ ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
+ ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
+ break;
+ }
+ case ModulationOrder_qam64:
+ {
+ ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
+ break;
+ }
+ case ModulationOrder_qam256:
+ {
+ ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
+ memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
+ break;
+ }
+ }
+ }
+ else
+ {
+ memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Function to extract cellGrp Info present in cutoDu cont
+ *
+ * @details
+ *
+ * Function : extractCellGrpInfo
+ *
+ * Functionality: Function to extract cellGrp Info present
+ * in cutoDu cont
+ *
+ * @params[in] ProtocolExtensionContainer_4624P16_t pointer
+ *
+ * @return CellGroupConfigRrc_t *
+ *
+ * ****************************************************************/
+
+CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
+ DuUeCfg *ueCfgDb)
+{
+ uint8_t idx2 =0;
+ uint16_t id =0;
+ uint16_t recvBufLen =0;
+ CellGroupConfigRrc_t *cellGrpCfg = NULLP;
+ CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
+ asn_dec_rval_t rval; /* Decoder return value */
+ memset(&rval, 0, sizeof(asn_dec_rval_t));
+
+ if(protocolIeExtn)
+ {
+ for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
+ {
+ extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
+ id = extIeInfo->id;
+ switch(id)
+ {
+ case ProtocolIE_ID_id_CellGroupConfig:
+ {
+ recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
+ /* decoding the CellGroup Buf received */
+ DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
+ if(cellGrpCfg)
+ {
+ memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
+ rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
+ extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
+ if(rval.code == RC_FAIL || rval.code == RC_WMORE)
+ {
+ DU_LOG("\nERROR --> F1AP : ASN decode failed at decodeCellGrpCfg()");
+ return NULLP;
+ }
+ xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
+ if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
+ return NULLP;
+ }
+ break;
+ }
+ default:
+ DU_LOG("\nERROR --> F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
+ break;
+ }
+ }
+ }
+ return cellGrpCfg;
+}
+
+/*******************************************************************
+ *
+ * @brief Fills Srb List received by CU
+ *
+ * @details
+ *
+ * Function : procSrbListToSetup
+ *
+ * Functionality: Fills Srb List received by CU
+ *
+ * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
+ * LcCfg pointer
+ * RlcBearerCfg pointer
+ * @return void
+ *
+ * ****************************************************************/
+uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
+{
+ uint8_t ret = ROK;
+
+ /* Filling RLC INFO */
+ procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
+
+ /* Filling MAC INFO */
+ ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
+ return ret;
+ }
+ return ret;
+}
+
+
+
+/*******************************************************************
+ *
+ * @brief extract Srb List received by CU
+ *
+ * @details
+ *
+ * Function : extractSrbListToSetup
+ *
+ * Functionality: extract Srb List received by CU
+ * for both MAC and RLC
+ *
+ * @params[in] SRBs_ToBeSetup_Item_t pointer
+ * DuUeCfg pointer
+ * @return ROK/RFAIED
+ *
+ * ****************************************************************/
+
+uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
+{
+ uint8_t ret, srbIdx;
+ SRBs_ToBeSetup_Item_t *srbItem = NULLP;
+
+ if(srbCfg)
+ {
+ for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
+ {
+ srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
+ if(ueCfgDb->numMacLcs > MAX_NUM_LC)
+ {
+ DU_LOG("\nERROR --> F1AP: MAX LC Reached in MAC");
+ ret = RFAILED;
+ break;
+ }
+ if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
+ {
+ DU_LOG("\nERROR --> F1AP: MAX LC Reached in RLC");
+ ret = RFAILED;
+ break;
+ }
+ memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
+ memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
+ ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
+ &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
+ ueCfgDb->numRlcLcs++;
+ ueCfgDb->numMacLcs++;
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> F1AP: Failed at extractSrbListToSetup()");
+ break;
+ }
+ }
+ }
+ else
+ ret = RFAILED;
+
+ return ret;
+}