*******************************************************************************/
/* This file contains F1AP message handler functions */
-
+#include "common_def.h"
+#include "lrg.h"
+#include "legtp.h"
+#include "lkw.x"
+#include "lrg.x"
+#include "du_cfg.h"
+#include "E2AP-PDU.h"
#include "du_mgr.h"
#include "du_mgr_main.h"
#include "du_cell_mgr.h"
#include "PhysicalCellGroupConfig.h"
#include "SpCellConfig.h"
#include "ServingCellConfig.h"
+#include "ControlResourceSet.h"
+#include "SearchSpace.h"
+#include "PDCCH-Config.h"
+#include "PDSCH-TimeDomainResourceAllocation.h"
+#include "PDSCH-TimeDomainResourceAllocationList.h"
+#include "DMRS-DownlinkConfig.h"
+#include "PDSCH-Config.h"
#include "BWP-DownlinkDedicated.h"
+#include "PUSCH-TimeDomainResourceAllocation.h"
+#include "PUSCH-TimeDomainResourceAllocationList.h"
+#include "DMRS-UplinkConfig.h"
+#include "PUSCH-Config.h"
+#include "SRS-ResourceId.h"
+#include "SRS-Resource.h"
+#include "SRS-ResourceSet.h"
+#include "SRS-Config.h"
+#include "BWP-UplinkDedicated.h"
+#include "PUSCH-ServingCellConfig.h"
#include "UplinkConfig.h"
+#include "PDSCH-ServingCellConfig.h"
#include "DUtoCURRCContainer.h"
+#include<ProtocolIE-Field.h>
+#include "ProtocolExtensionField.h"
+#include "F1AP-PDU.h"
+S16 procGNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg);
+uint8_t procDlRrcMsgTrans(F1AP_PDU_t *f1apMsg);
+void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg);
extern char encBuf[ENC_BUF_MAX_LEN];
extern DuCfgParams duCfgParam;
uint8_t BuildULTnlInforet=RFAILED;
uint8_t Nrcgiret=RFAILED;
uint8_t SplCellListret=RFAILED;
uint8_t SRBSetupret=RFAILED;
+uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp);
+
/*******************************************************************
*
* @brief Builds Uplink Info for NR
/*******************************************************************
*
- * @brief Builds intitial DL BWP
+ * @brief Build Control resource set to add/modify list
+ *
* @details
*
- * Function : BuildInitialDlBWP
+ * Function : BuildControlRSetToAddModList
*
- * Functionality: Builds intitial DL BWP in spCellCfgDed
+ * Functionality: Build Control resource set to add/modify list
*
- * @params[in] BWP_DownlinkDedicated_t *dlBwp
+ * @params[in]
+ * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
*
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
+uint8_t BuildControlRSetToAddModList
+(
+struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
+)
{
+ uint8_t idx;
+ uint8_t elementCnt;
+ uint8_t numBytes;
+ uint8_t byteIdx;
+ uint8_t bitsUnused;
+ struct ControlResourceSet *controlRSet;
+
+ elementCnt = 1;
+ controlRSetList->list.count = elementCnt;
+ controlRSetList->list.size = \
+ elementCnt * sizeof(struct ControlResourceSet *);
+
+ controlRSetList->list.array = NULLP;
+ DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
+ if(!controlRSetList->list.array)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ controlRSetList->list.array[idx] = NULLP;
+ DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
+ if(!controlRSetList->list.array[idx])
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ }
+
+ idx=0;
+ controlRSet = controlRSetList->list.array[idx];
+
+ controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
+
+ /* Values taken from reference logs :
+ * 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;
+ DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
+ controlRSet->frequencyDomainResources.size);
+ if(!controlRSet->frequencyDomainResources.buf)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ byteIdx = 0;
+ controlRSet->frequencyDomainResources.buf[byteIdx] = PDCCH_FREQ_DOM_RSRC; /* setting 8 MSBs i.e. ff */
+ for(byteIdx = 1; byteIdx < numBytes; byteIdx++)
+ {
+ controlRSet->frequencyDomainResources.buf[byteIdx] = 0;
+ }
+ 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;
+
+ DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
+ sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
+ if(!controlRset->tci_StatesPDCCH_ToAddList)
+ {
+ DU_LOG("\nF1AP : 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 *);
+ DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
+ controlRset->tci_StatesPDCCH_ToAddList->list.size)
+ if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+
+ for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
+ {
+ DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
+ if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ }
+
+ tciStateIdx = 0;
+ /* TODO */
+ *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
+
+ DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
+ if(!controlRset->tci_PresentInDCI)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ /* TODO */
+ *(controlRset->tci_PresentInDCI);
+#endif
+
+ controlRSet->pdcch_DMRS_ScramblingID = NULLP;
+ DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
+ if(!controlRSet->pdcch_DMRS_ScramblingID)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
return ROK;
-}
+} /* End BuildControlRSetToAddModList */
/*******************************************************************
*
- * @brief Builds UL config
- * @details
+ * @brief Build search space to add/modify list
*
- * Function : BuildUlCfg
+ * @details
*
- * Functionality: Builds UL config in spCellCfgDed
+ * Function : BuildSearchSpcToAddModList
*
- * @params[in] UplinkConfig_t *ulCfg
+ * Functionality: Build search space to add/modify list
*
+ * @params[in]
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
+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;
+ DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
+ if(!searchSpcList->list.array)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ searchSpcList->list.array[idx] = NULLP;
+ DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
+ if(!searchSpcList->list.array[idx])
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ searchSpc = searchSpcList->list.array[idx];
+
+ searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
+
+ searchSpc->controlResourceSetId = NULLP;
+ DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
+ if(!searchSpc->controlResourceSetId)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
+
+ searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
+ DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
+ sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
+ if(!searchSpc->monitoringSlotPeriodicityAndOffset)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+ searchSpc->monitoringSlotPeriodicityAndOffset->present = \
+ SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
+
+ searchSpc->duration = NULLP;
+ searchSpc->monitoringSymbolsWithinSlot = NULLP;
+ DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
+ if(!searchSpc->monitoringSymbolsWithinSlot)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+
+ /* Values taken from reference logs :
+ * size 2 bytes
+ * 2 LSBs unsued
+ * Bit string stores 8000
+ */
+ numBytes = 2;
+ bitsUnused = 2;
+
+ searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
+ searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
+ DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
+ searchSpc->monitoringSymbolsWithinSlot->size);
+ if(!searchSpc->monitoringSymbolsWithinSlot->buf)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
+ if(!searchSpc->nrofCandidates)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
+ if(!searchSpc->searchSpaceType)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
+ return RFAILED;
+ }
+
+ searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
+
+ searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
+ DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
+ sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
+ if(!searchSpc->searchSpaceType->choice.ue_Specific)
+ {
+ DU_LOG("\nF1AP : 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 PDSCH serving cell config
+ * @brief Builds BWP DL dedicated PDCCH config
+ *
* @details
*
- * Function : BuildPdschSrvCellCfg
+ * Function : BuildBWPDlDedPdcchCfg
*
- * Functionality: Builds PDSCH serving cell config in spCellCfgDed
+ * Functionality: Builds BWP DL dedicated PDCCH config
*
- * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
+ * @params[in] struct PDCCH_Config *pdcchCfg
*
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
+uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
{
+ pdcchCfg->controlResourceSetToAddModList = NULLP;
+ DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
+ sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
+ if(!pdcchCfg->controlResourceSetToAddModList)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
+ return RFAILED;
+ }
+
+ if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
+ {
+ return RFAILED;
+ }
+
+ pdcchCfg->controlResourceSetToReleaseList = NULLP;
+
+ pdcchCfg->searchSpacesToAddModList = NULLP;
+ DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
+ sizeof(struct PDCCH_Config__searchSpacesToAddModList));
+ if(!pdcchCfg->searchSpacesToAddModList)
+ {
+ DU_LOG("\nF1AP : 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 CSI Meas config
- * @details
+ * @brief Builds DMRS DL PDSCH Mapping type A
*
- * Function : BuildCsiMeasCfg
+ * @details
*
- * Functionality: Builds CSI Meas config in spCellCfgDed
+ * Function : BuildDMRSDLPdschMapTypeA
*
- * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
+ * Functionality: Builds DMRS DL PDSCH Mapping type A
*
+ * @params[in]
+ * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
+uint8_t BuildDMRSDLPdschMapTypeA
+(
+struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
+)
{
+ dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
+ dmrsDlCfg->choice.setup = NULLP;
+ DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
+ if(!dmrsDlCfg->choice.setup)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
+ return RFAILED;
+ }
+
+ dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
+ dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
+ DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
+ if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
+ {
+ DU_LOG("\nF1AP : 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 Spcell config dedicated
+ * @brief Builds TCI states to add/modify list
+ *
* @details
*
- * Function : BuildSpCellCfgDed
+ * Function : BuildTCIStatesToAddModList
*
- * Functionality: Builds sp cell config dedicated in spCellCfg
+ * Functionality:Builds TCI states to add/modify list
*
- * @params[in] ServingCellConfig_t srvCellCfg
+ * @params[in]
+ * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
*
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
+uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
{
-#if 0
- srvCellCfg->initialDownlinkBWP = NULLP;
- DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
- if(!srvCellCfg->initialDownlinkBWP)
- {
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
- return RFAILED;
- }
+ return ROK;
+}
- if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
- {
- DU_LOG("\nF1AP : BuildInitialDlBWP failed");
- return RFAILED;
- }
-#endif
- srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
- DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
- if(!srvCellCfg->firstActiveDownlinkBWP_Id)
- {
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
- return RFAILED;
- }
- *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
+/*******************************************************************
+ *
+ * @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;
- srvCellCfg->defaultDownlinkBWP_Id = NULLP;
- DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
- if(!srvCellCfg->defaultDownlinkBWP_Id)
- {
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
- return RFAILED;
- }
- *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
-#if 0
- srvCellCfg->uplinkConfig = NULLP;
- DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
- if(!srvCellCfg->uplinkConfig)
- {
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
- return RFAILED;
- }
+ timeDomAllocList->present = \
+ PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
- if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
+ timeDomAllocList->choice.setup = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup, \
+ sizeof(struct PDSCH_TimeDomainResourceAllocationList));
+ if(!timeDomAllocList->choice.setup)
{
- DU_LOG("\nF1AP : BuildUlCfg failed");
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
-
- srvCellCfg->pdsch_ServingCellConfig = NULLP;
- DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
- if(!srvCellCfg->pdsch_ServingCellConfig)
+
+ elementCnt = 1;
+ timeDomAllocList->choice.setup->list.count = elementCnt;
+ timeDomAllocList->choice.setup->list.size = \
+ elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
+
+ timeDomAllocList->choice.setup->list.array = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
+ timeDomAllocList->choice.setup->list.size);
+ if(!timeDomAllocList->choice.setup->list.array)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
return RFAILED;
}
- if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
+ for(idx = 0; idx < elementCnt; idx++)
{
- DU_LOG("\nF1AP : BuildPdschSrvCellCfg failed");
- return RFAILED;
+ timeDomAllocList->choice.setup->list.array[idx] = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
+ sizeof(struct PDSCH_TimeDomainResourceAllocation));
+ if(!timeDomAllocList->choice.setup->list.array[idx])
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
}
- srvCellCfg->csi_MeasConfig = NULLP;
- DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct ServingCellConfig__csi_MeasConfig))
- if(!srvCellCfg->csi_MeasConfig)
- {
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
- return RFAILED;
- }
+ idx = 0;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
- if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
- {
- DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
- return RFAILED;
- }
-#endif
- srvCellCfg->tag_Id = TAG_ID;
+ timeDomAlloc->k0 = NULLP;
+ timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = \
+ calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
- return ROK;
+ return ROK;
}
+
/*******************************************************************
*
- * @brief Builds Spcell config
+ * @brief Builds PDSCH PRB Bundling type
*
* @details
*
- * Function : BuildSpCellCfg
+ * Function : BuildPdschPrbBundlingType
*
- * Functionality: Builds sp cell config in DuToCuRrcContainer
+ * Functionality: Builds PDSCH PRB Bundling type
*
- * @params[in] SpCellConfig_t spCellCfg
+ * @params[in]
+ * struct PDSCH_Config__prb_BundlingType *prbBndlType
*
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
+uint8_t BuildPdschPrbBundlingType
+(
+struct PDSCH_Config__prb_BundlingType *prbBndlType
+)
{
+ prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
- spCellCfg->servCellIndex = NULLP;
- DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
- if(!spCellCfg->servCellIndex)
+ prbBndlType->choice.staticBundling = NULLP;
+ DU_ALLOC(prbBndlType->choice.staticBundling, \
+ sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
+ if(!prbBndlType->choice.staticBundling)
{
- DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPdschPrbBundlingType");
return RFAILED;
}
- *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
+ prbBndlType->choice.staticBundling->bundleSize = NULLP;
- spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
- DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
- if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
+ 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;
+ DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
+ sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
+ if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
+ {
+ DU_LOG("\nF1AP : 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
+ DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
+ if(!pdschCfg->tci_StatesToAddModList)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
+ sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
+ if(!pdschCfg->pdsch_TimeDomainAllocationList)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
+ if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
+ if(!dlBwp->pdcch_Config)
+ {
+ DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
+ return RFAILED;
+ }
+ dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
+
+ dlBwp->pdcch_Config->choice.setup = NULLP;
+ DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
+ if(!dlBwp->pdcch_Config->choice.setup)
+ {
+ DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
+ return RFAILED;
+ }
+ if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
+
+ dlBwp->pdsch_Config = NULLP;
+ DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
+ if(!dlBwp->pdsch_Config)
+ {
+ DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
+ return RFAILED;
+ }
+ dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
+
+ dlBwp->pdsch_Config->choice.setup = NULLP;
+ DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
+ if(!dlBwp->pdsch_Config->choice.setup)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
+ if(!dmrsUlCfg->choice.setup)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ return RFAILED;
+ }
+
+ dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
+ dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
+ DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
+ if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
+ sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
+ if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
+ return RFAILED;
+ }
+
+ dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
+ DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
+ sizeof(long));
+ if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(timeDomAllocList->choice.setup, \
+ sizeof(struct PUSCH_TimeDomainResourceAllocationList));
+ if(!timeDomAllocList->choice.setup)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ timeDomAllocList->choice.setup->list.count = elementCnt;
+ timeDomAllocList->choice.setup->list.size = \
+ elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
+ timeDomAllocList->choice.setup->list.array = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
+ timeDomAllocList->choice.setup->list.size);
+ if(!timeDomAllocList->choice.setup->list.array)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ timeDomAllocList->choice.setup->list.array[idx] = NULLP;
+ DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
+ sizeof(PUSCH_TimeDomainResourceAllocation_t));
+ if(!timeDomAllocList->choice.setup->list.array[idx])
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ DU_ALLOC(timeDomAlloc->k2, sizeof(long));
+ if(!timeDomAlloc->k2)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k2) = PUSCH_K2;
+ timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
+ 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;
+ DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
+ if(!puschCfg->dataScramblingIdentityPUSCH)
+ {
+ DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
+ return RFAILED;
+ }
+ *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
+
+ puschCfg->txConfig = NULLP;
+ puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
+ DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
+ sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
+ if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
+ {
+ DU_LOG("\nF1AP: 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;
+ DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
+ sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
+ if(!puschCfg->pusch_TimeDomainAllocationList)
+ {
+ DU_LOG("\nF1AP: 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;
+ DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
+ if(!puschCfg->transformPrecoder)
+ {
+ DU_LOG("\nF1AP: 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 Fills SRS resource to add/modify list
+ *
+ * @details
+ *
+ * Function : BuildSrsRsrcAddModList
+ *
+ * Functionality: Fills SRS resource to add/modify list
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
+{
+ uint8_t elementCnt;
+ uint8_t rsrcIdx;
+
+ elementCnt = 1;
+ resourceList->list.count = elementCnt;
+ resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
+ resourceList->list.array = NULLP;
+ DU_ALLOC(resourceList->list.array, resourceList->list.size);
+ if(!resourceList->list.array)
+ {
+ DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ return RFAILED;
+ }
+
+ for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
+ {
+ DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
+ if(!resourceList->list.array[rsrcIdx])
+ {
+ DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ return RFAILED;
+ }
+ }
+
+ rsrcIdx = 0;
+ resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
+ resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
+ resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
+
+ resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
+ DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
+ sizeof(struct SRS_Resource__transmissionComb__n2));
+ if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
+ {
+ DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
+ return RFAILED;
+ }
+ resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
+ = SRS_COMB_OFFSET_N2;
+ resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
+ = SRS_CYCLIC_SHIFT_N2;
+
+ resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
+ PUSCH_START_SYMBOL;
+ resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols = \
+ SRS_Resource__resourceMapping__nrofSymbols_n1;
+ resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
+ SRS_Resource__resourceMapping__repetitionFactor_n1;
+
+ resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
+ resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
+ resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
+ resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
+ resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
+ resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
+ SRS_Resource__groupOrSequenceHopping_neither;
+
+ /* Setting resource type to aperiodic for intergration purposes */
+ resourceList->list.array[rsrcIdx]->resourceType.present = \
+ SRS_Resource__resourceType_PR_aperiodic;
+ resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
+ DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
+ sizeof(struct SRS_Resource__resourceType__aperiodic));
+ if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
+ {
+ DU_LOG("\nF1AP: 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;
+ DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
+ if(!rsrcSetList->list.array)
+ {
+ DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ return RFAILED;
+ }
+
+ for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
+ {
+ DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
+ if(!rsrcSetList->list.array[rSetIdx])
+ {
+ DU_LOG("\nF1AP: 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;
+ DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
+ sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
+ if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
+ {
+ DU_LOG("\nF1AP: 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;
+ DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
+ if(!rsrcIdList->list.array)
+ {
+ DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
+ return RFAILED;
+ }
+
+ for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
+ {
+ DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
+ if(!rsrcIdList->list.array[rsrcIdx])
+ {
+ DU_LOG("\nF1AP: 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;
+ DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
+ sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
+ if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
+ {
+ DU_LOG("\nF1AP: 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;
+ DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
+ sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
+ if(!srsCfg->srs_ResourceSetToAddModList)
+ {
+ DU_LOG("\nF1AP: 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;
+ DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
+ sizeof(struct SRS_Config__srs_ResourceToAddModList));
+ if(!srsCfg->srs_ResourceToAddModList)
+ {
+ DU_LOG("\nF1AP: 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;
+
+ /* Fill BWP UL dedicated PUSCH config */
+ ulBwp->pusch_Config = NULLP;
+ DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
+ if(!ulBwp->pusch_Config)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
+ ulBwp->pusch_Config->choice.setup = NULLP;
+ DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
+ if(!ulBwp->pusch_Config->choice.setup)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
+ if(!ulBwp->srs_Config)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
+ ulBwp->srs_Config->choice.setup = NULLP;
+ DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
+ if(!ulBwp->srs_Config->choice.setup)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
+ if(!puschCfg->choice.setup)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
+ if(!puschCfg->choice.setup->ext1)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ return RFAILED;
+ }
+
+ puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
+ DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
+ if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
+ return RFAILED;
+ }
+ *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
+
+ puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
+ DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
+ if(!puschCfg->choice.setup->ext1->processingType2Enabled)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
+ if(!ulCfg->initialUplinkBWP)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
+ if(!ulCfg->firstActiveUplinkBWP_Id)
+ {
+ DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
+ return RFAILED;
+ }
+ *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
+
+ ulCfg->pusch_ServingCellConfig = NULLP;
+ DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
+ sizeof(struct UplinkConfig__pusch_ServingCellConfig));
+ if(!ulCfg->pusch_ServingCellConfig)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
+ if(!pdschCfg->choice.setup)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
+ return RFAILED;
+ }
+
+ pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
+ pdschCfg->choice.setup->xOverhead = NULLP;
+ pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
+ DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
+ if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
+ if(!srvCellCfg->initialDownlinkBWP)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+
+ if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
+ {
+ DU_LOG("\nF1AP : BuildInitialDlBWP failed");
+ return RFAILED;
+ }
+ srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
+ srvCellCfg->downlinkBWP_ToAddModList = NULLP;
+
+ srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
+ DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
+ if(!srvCellCfg->firstActiveDownlinkBWP_Id)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+ *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
+
+ srvCellCfg->bwp_InactivityTimer = NULLP;
+
+ srvCellCfg->defaultDownlinkBWP_Id = NULLP;
+ DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
+ if(!srvCellCfg->defaultDownlinkBWP_Id)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+ *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
+
+ srvCellCfg->uplinkConfig = NULLP;
+ DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
+ if(!srvCellCfg->uplinkConfig)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+
+ if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
+ {
+ DU_LOG("\nF1AP : BuildUlCfg failed");
+ return RFAILED;
+ }
+ srvCellCfg->supplementaryUplink = NULLP;
+ srvCellCfg->pdcch_ServingCellConfig = NULLP;
+
+ srvCellCfg->pdsch_ServingCellConfig = NULLP;
+ DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
+ if(!srvCellCfg->pdsch_ServingCellConfig)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
+ return RFAILED;
+ }
+
+ if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
+ {
+ DU_LOG("\nF1AP : BuildPdschSrvCellCfg failed");
+ return RFAILED;
+ }
+
+ srvCellCfg->csi_MeasConfig = NULLP;
+#if 0
+ DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct ServingCellConfig__csi_MeasConfig))
+ if(!srvCellCfg->csi_MeasConfig)
+ {
+ DU_LOG("\nF1AP : 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;
+ DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
+ if(!spCellCfg->servCellIndex)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
+ return RFAILED;
+ }
+ *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
+
+ spCellCfg->reconfigurationWithSync = NULLP;
+ spCellCfg->rlf_TimersAndConstants = NULLP;
+ spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
+ DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
+ if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
{
DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
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)
+ {
+ DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
+ sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
+ DU_FREE(searchSpc->searchSpaceType, sizeof(struct
+ SearchSpace__searchSpaceType));
+ }
+ DU_FREE(searchSpc->nrofCandidates,
+ sizeof(struct SearchSpace__nrofCandidates));
+ }
+ DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
+ searchSpc->monitoringSymbolsWithinSlot->size);
+ }
+ DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
+ sizeof(BIT_STRING_t));
+ }
+ DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
+ sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
+ }
+ DU_FREE(searchSpc->controlResourceSetId,
+ sizeof(ControlResourceSetId_t));
+ }
+ }
+ for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
+ {
+ DU_FREE(searchSpcList->list.array[idx1],
+ sizeof(struct SearchSpace));
+ }
+ DU_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++)
+ {
+ DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
+ sizeof(struct PDSCH_TimeDomainResourceAllocation));
+ }
+ DU_FREE(timeDomAllocList->choice.setup->list.array, \
+ timeDomAllocList->choice.setup->list.size);
+ }
+ DU_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
+ *
+ 4221 * ****************************************************************/
+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)
+ {
+ DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
+ for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
+ {
+ DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
+ sizeof(PUSCH_TimeDomainResourceAllocation_t));
+ }
+ DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
+ timeDomAllocList_t->choice.setup->list.size);
+ }
+ DU_FREE(timeDomAllocList_t->choice.setup, \
+ sizeof(struct PUSCH_TimeDomainResourceAllocationList));
+ }
+ DU_FREE(puschCfg->transformPrecoder, sizeof(long));
+ DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
+ sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
+ }
+
+}
+ /*******************************************************************
+ *
+ * @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;
+
+ 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)
+ {
+ DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
+ sizeof(long));
+ DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
+ sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
+ }
+ DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
+ sizeof(long));
+ }
+ DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
+ }
+ DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
+ sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
+ }
+ DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
+ }
+ DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
+ }
+ DU_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++)
+ {
+ DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
+ }
+ DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
+ }
+ DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
+ sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
+ }
+
+ /* Free resource type info for this SRS resource set */
+ DU_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++)
+ {
+ DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
+ }
+ DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
+ }
+ DU_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;
+ DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
+ sizeof(struct SRS_Resource__transmissionComb__n2));
+ DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
+ sizeof(struct SRS_Resource__resourceType__aperiodic));
+
+ for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
+ {
+ DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
+ }
+ DU_FREE(resourceList->list.array, resourceList->list.size);
+ }
+ DU_FREE(srsCfg->srs_ResourceToAddModList, \
+ sizeof(struct SRS_Config__srs_ResourceToAddModList));
+ }
+
+ DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
+ }
+ DU_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)
+ {
+ DU_FREE(puschCfg->choice.setup->ext1->\
+ processingType2Enabled,sizeof(BOOLEAN_t));
+ DU_FREE(puschCfg->choice.setup->ext1->\
+ maxMIMO_Layers,sizeof(long));
+ DU_FREE(puschCfg->choice.setup->ext1, \
+ sizeof(struct PUSCH_ServingCellConfig__ext1));
+ }
+ DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
+ }
+ DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
+ }
+ DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
+ }
+ FreeInitialUlBWP(ulBwp);
+ DU_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;
+ DU_FREE(prbBndlType->choice.staticBundling,\
+ sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
+ DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
+ }
+ FreePdschTimeDomAllocList(timeDomAllocList);
+ DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
+ sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
+ }
+ dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
+ if(dmrsDlCfg->choice.setup)
+ {
+ DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
+ sizeof(long));
+ DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
+ }
+ DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
+ sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
+ }
+ DU_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);
+ DU_FREE(pdcchCfg->searchSpacesToAddModList, \
+ sizeof(struct PDCCH_Config__searchSpacesToAddModList));
+ }
+ DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
+ }
+ DU_FREE(controlRSet->frequencyDomainResources.buf, \
+ controlRSet->frequencyDomainResources.size);
+ }
+ }
+ for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
+ {
+ DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
+ }
+ DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
+ }
+ DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
+ sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
+ }
+ DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
+ }
+}
/*******************************************************************
*
*
* Function : FreeMemDuToCuRrcCont
*
- * Functionality: Builds DuToCuRrcContainer
+ * Functionality: Deallocating memory of DuToCuRrcContainer
*
* @params[in] DuToCuRRCContainer, DuToCuRRCContainer
*
* ****************************************************************/
uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
{
- uint8_t idx;
- struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList;
- struct RLC_Config *rlcConfig;
- struct LogicalChannelConfig *macLcConfig;
- MAC_CellGroupConfig_t *macCellGrpCfg;
- struct SchedulingRequestConfig *schedulingRequestConfig;
- struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
- struct TAG_Config *tagConfig;
- struct TAG_Config__tag_ToAddModList *tagList;
- struct MAC_CellGroupConfig__phr_Config *phrConfig;
- PhysicalCellGroupConfig_t *phyCellGrpCfg;
- SpCellConfig_t *spCellCfg;
- ServingCellConfig_t *srvCellCfg;
+ 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)
{
for(idx=0; idx<rlcBearerList->list.count; idx++)
{
- rlcConfig = rlcBearerList->list.array[idx]->rlc_Config;
- macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
- if(rlcConfig)
- {
- if(rlcConfig->choice.am)
- {
- DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
- DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
- DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
- }
- DU_FREE(rlcConfig, sizeof(struct RLC_Config));
- }
- DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
- if(macLcConfig)
- {
- if(macLcConfig->ul_SpecificParameters)
- {
- DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
- DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
- DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
+ 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)
+ {
+ DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
+ }
+ DU_FREE(rlcConfig, sizeof(struct RLC_Config));
+ }
+ DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
+ if(macLcConfig)
+ {
+ if(macLcConfig->ul_SpecificParameters)
+ {
+ DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
+ DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
+ DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
+ }
+ DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
}
- DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
- }
- DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
+ DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
+ }
}
DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
}
if(macCellGrpCfg)
{
schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
- schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
-
if(schedulingRequestConfig)
{
- if(schReqList)
+ schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
+ if(schReqList)
{
if(schReqList->list.array)
{
sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList)); }
DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
}
-
if(macCellGrpCfg->bsr_Config)
{
DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
}
-
tagConfig = macCellGrpCfg->tag_Config;
- tagList = tagConfig->tag_ToAddModList;
if(tagConfig)
{
- if(tagList)
+ tagList = tagConfig->tag_ToAddModList;
+ if(tagList)
{
if(tagList->list.array)
{
}
DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
}
- DU_FREE(tagConfig, sizeof(struct TAG_Config));
+ DU_FREE(tagConfig, sizeof(struct TAG_Config));
}
phrConfig = macCellGrpCfg->phr_Config;
spCellCfg = cellGrpCfg->spCellConfig;
if(spCellCfg)
{
- DU_FREE(spCellCfg->servCellIndex, sizeof(long));
- DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
-
- srvCellCfg = spCellCfg->spCellConfigDedicated;
- if(srvCellCfg)
+ if(spCellCfg->servCellIndex)
{
- DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
- DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
- DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
- DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
- DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
- DU_FREE(srvCellCfg->csi_MeasConfig, sizeof(struct ServingCellConfig__csi_MeasConfig));
- DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
- }
- DU_FREE(spCellCfg, sizeof(SpCellConfig_t));
+ 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)
+ {
+ DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
+ DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
+ }
+ DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
+ ServingCellConfig__pdsch_ServingCellConfig));
+ }
+ FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
+ DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
+ }
+ DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
+ }
+ DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
+ }
+ if(dlBwp->pdcch_Config)
+ {
+ if(dlBwp->pdsch_Config)
+ {
+ FreeBWPDlDedPdschCfg(dlBwp);
+ DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
+ }
+ FreeBWPDlDedPdcchCfg(dlBwp);
+ DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
+ }
+ DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
+ }
+ DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
+ }
+ DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
+ }
+ DU_FREE(spCellCfg->servCellIndex, sizeof(long));
+ }
+ DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
}
return ROK;
}