#define PDSCH_PDU_TYPE 1
#define SSB_PDU_TYPE 3
#define PRACH_PDU_TYPE 0
+#define PUSCH_PDU_TYPE 1
#define PDU_PRESENT 1
#define SET_MSG_LEN(x, size) x += size
if(ulTtiReq)
ulTtiReq->rachPresent = PDU_PRESENT;
}
- if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
- {
- pduCount++;
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH)
+ {
+ pduCount++;
+ if(ulTtiReq)
+ ulTtiReq->nUlsch++;
+ }
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
+ {
+ pduCount++;
if(ulTtiReq)
ulTtiReq->nUlsch = PDU_PRESENT;
}
sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_prach_pdu_t)));
}
}
+
+void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
+{
+ if(ulTtiReqPdu != NULLP)
+ {
+ ulTtiReqPdu->pduType = PUSCH_PDU_TYPE;
+ ulTtiReqPdu->u.pusch_pdu.pduBitMap = 1;
+ ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulCellInfo.crnti;
+ /* TODO : Fill handle in raCb when scheduling pusch and access here */
+ ulTtiReqPdu->u.pusch_pdu.handle = 100;
+ ulTtiReqPdu->u.pusch_pdu.bwpSize = macCellCfg->initialUlBwp.bwp.numPrb;
+ ulTtiReqPdu->u.pusch_pdu.bwpStart = macCellCfg->initialUlBwp.bwp.firstPrb;
+ ulTtiReqPdu->u.pusch_pdu.subCarrierSpacing = \
+ macCellCfg->initialUlBwp.bwp.scs;
+ ulTtiReqPdu->u.pusch_pdu.cyclicPrefix = \
+ macCellCfg->initialUlBwp.bwp.cyclicPrefix;
+ ulTtiReqPdu->u.pusch_pdu.targetCodeRate = 308;
+ ulTtiReqPdu->u.pusch_pdu.qamModOrder = 2;
+ ulTtiReqPdu->u.pusch_pdu.mcsIndex = \
+ currUlSlot->ulCellInfo.schPuschInfo.tbInfo.mcs;
+ ulTtiReqPdu->u.pusch_pdu.mcsTable = 0;
+ ulTtiReqPdu->u.pusch_pdu.transformPrecoding = 1;
+ ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulCellInfo.cellId;
+ ulTtiReqPdu->u.pusch_pdu.nrOfLayers = 1;
+ ulTtiReqPdu->u.pusch_pdu.ulDmrsSymbPos = 4;
+ ulTtiReqPdu->u.pusch_pdu.dmrsConfigType = 0;
+ ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulCellInfo.cellId;
+ ulTtiReqPdu->u.pusch_pdu.scid = 0;
+ ulTtiReqPdu->u.pusch_pdu.numDmrsCdmGrpsNoData = 1;
+ ulTtiReqPdu->u.pusch_pdu.dmrsPorts = 0;
+ ulTtiReqPdu->u.pusch_pdu.resourceAlloc = \
+ currUlSlot->ulCellInfo.schPuschInfo.resAllocType;
+ ulTtiReqPdu->u.pusch_pdu.rbStart = \
+ currUlSlot->ulCellInfo.schPuschInfo.fdAlloc.startPrb;
+ ulTtiReqPdu->u.pusch_pdu.rbSize = \
+ currUlSlot->ulCellInfo.schPuschInfo.fdAlloc.numPrb;
+ ulTtiReqPdu->u.pusch_pdu.vrbToPrbMapping = 0;
+ ulTtiReqPdu->u.pusch_pdu.frequencyHopping = 0;
+ ulTtiReqPdu->u.pusch_pdu.txDirectCurrentLocation = 0;
+ ulTtiReqPdu->u.pusch_pdu.uplinkFrequencyShift7p5khz = 0;
+ ulTtiReqPdu->u.pusch_pdu.startSymbIndex = \
+ currUlSlot->ulCellInfo.schPuschInfo.tdAlloc.startSymb;
+ ulTtiReqPdu->u.pusch_pdu.nrOfSymbols = \
+ currUlSlot->ulCellInfo.schPuschInfo.tdAlloc.numSymb;
+ ulTtiReqPdu->u.pusch_pdu.puschData.rvIndex = \
+ currUlSlot->ulCellInfo.schPuschInfo.tbInfo.rv;
+ ulTtiReqPdu->u.pusch_pdu.puschData.harqProcessId = \
+ currUlSlot->ulCellInfo.schPuschInfo.harqProcId;
+ ulTtiReqPdu->u.pusch_pdu.puschData.newDataIndicator = \
+ currUlSlot->ulCellInfo.schPuschInfo.tbInfo.ndi;
+ ulTtiReqPdu->u.pusch_pdu.puschData.tbSize = \
+ currUlSlot->ulCellInfo.schPuschInfo.tbInfo.tbSize;
+ /* numCb is 0 for new transmission */
+ ulTtiReqPdu->u.pusch_pdu.puschData.numCb = 0;
+
+ ulTtiReqPdu->pduSize = sizeof(fapi_ul_pusch_pdu_t);
+
+ SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
+ sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_pusch_pdu_t)));
+ }
+}
#endif
/*******************************************************************
if(ulTtiReq != NULLP)
{
+ memset(ulTtiReq, 0, msgSize);
ulTtiReq->sfn = currTimingInfo->sfn;
ulTtiReq->slot = currTimingInfo->slot;
ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot);
ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \
(sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*)));
/* Fill Prach Pdu */
- if(ulTtiReq->rachPresent)
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH)
{
pduIdx++;
fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
+ }
+
+ /* Fill PUSCH PDU */
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH)
+ {
+ pduIdx++;
+ fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
+ }
+ if((currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) || \
+ (currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH))
+ {
msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t));
fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
DU_LOG("\nLWR_MAC: Sending UL TTI Request");
LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
- }
+ }
}
else
{
DU_LOG("\nLWR_MAC: Sending UL TTI Request");
LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
}
+ memset(&currUlSlot, 0, sizeof(MacUlSlot));
return ROK;
}
else
{
DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
+ memset(&currUlSlot, 0, sizeof(MacUlSlot));
return RFAILED;
}
}
struct TAG_Config__tag_ToAddModList *tagList;
uint8_t idx, elementCnt;
+ tagConfig->tag_ToReleaseList = NULLP;
tagConfig->tag_ToAddModList = NULLP;
DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
if(!tagConfig->tag_ToAddModList)
elementCnt = 1; //ODU_VALUE_ONE;
tagList = tagConfig->tag_ToAddModList;
tagList->list.count = elementCnt;
- tagList->list.size = elementCnt * sizeof(struct TAG);
+ tagList->list.size = elementCnt * sizeof(struct TAG *);
tagList->list.array = NULLP;
DU_ALLOC(tagList->list.array, tagList->list.size);
{
bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
bsrConfig->retxBSR_Timer = RETX_BSR_TMR;
+ bsrConfig->logicalChannelSR_DelayTimer = NULLP;
return ROK;
}
elementCnt = 1; //ODU_VALUE_ONE;
schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
schReqList->list.count = elementCnt;
- schReqList->list.size = elementCnt * sizeof(SchedulingRequestId_t);
+ schReqList->list.size = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
schReqList->list.array = NULLP;
DU_ALLOC(schReqList->list.array, schReqList->list.size);
for(idx=0;idx<schReqList->list.count; idx++)
{
schReqList->list.array[idx] = NULLP;
- DU_ALLOC(schReqList->list.array[idx], sizeof(SchedulingRequestId_t));
+ DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
if(!schReqList->list.array[idx])
{
DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
return RFAILED;
}
*(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
-
schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
+ schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
return ROK;
}
rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold = MAX_RETX_THRESHOLD;
/* DL */
- rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
+ rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
{
*(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
rlcConfig->choice.am->dl_AM_RLC.t_Reassembly = T_REASSEMBLY;
rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit = T_STATUS_PROHIBHIT;
-
+
return ROK;
}
macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
macLcConfig->ul_SpecificParameters->prioritisedBitRate = PRIORTISIED_BIT_RATE;
macLcConfig->ul_SpecificParameters->bucketSizeDuration = BUCKET_SIZE_DURATION;
+ macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
+ macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
+ macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
+ macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
+ macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
return ROK;
}
elementCnt = 1;
rlcBearerList->list.count = elementCnt;
- rlcBearerList->list.size = elementCnt * sizeof(struct RLC_BearerConfig);
+ rlcBearerList->list.size = elementCnt * sizeof(struct RLC_BearerConfig *);
rlcBearerList->list.array = NULLP;
DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB_ID_1;
+ rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
rlcBearerList->list.array[idx]->rlc_Config = NULLP;
DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
if(!rlcBearerList->list.array[idx]->rlc_Config)
* ****************************************************************/
uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
{
-
+#if 0
srvCellCfg->initialDownlinkBWP = NULLP;
DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
if(!srvCellCfg->initialDownlinkBWP)
DU_LOG("\nF1AP : BuildInitialDlBWP failed");
return RFAILED;
}
-
+#endif
srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
if(!srvCellCfg->firstActiveDownlinkBWP_Id)
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 : BuildCsiMeasCfg failed");
return RFAILED;
}
-
+#endif
srvCellCfg->tag_Id = TAG_ID;
return ROK;
DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
return RFAILED;
}
-
if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
{
DU_LOG("\nF1AP : BuildSpCellCfgDed failed");
return RFAILED;
}
-
return ROK;
}
/*******************************************************************
* ****************************************************************/
uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
{
+ phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
+ phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
+
phyCellGrpCfg->p_NR_FR1 = NULLP;
DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
if(!phyCellGrpCfg->p_NR_FR1)
}
*(phyCellGrpCfg->p_NR_FR1) = P_NR_FR1;
phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
+ phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
+ phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
+ phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
+ phyCellGrpCfg->sp_CSI_RNTI = NULLP;
+ phyCellGrpCfg->cs_RNTI = NULLP;
+ phyCellGrpCfg->ext1 = NULLP;
+ phyCellGrpCfg->ext2 = NULLP;
return ROK;
}
* ****************************************************************/
uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
{
-
+ macCellGrpCfg->drx_Config = NULLP;
macCellGrpCfg->schedulingRequestConfig = NULLP;
DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
if(!macCellGrpCfg->schedulingRequestConfig)
}
macCellGrpCfg->skipUplinkTxDynamic = false;
+ macCellGrpCfg->ext1 = NULLP;
return ROK;
}
{
rlcConfig = rlcBearerList->list.array[idx]->rlc_Config;
macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
- 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));
+ 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));
- 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));
+ 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], sizeof(struct RLC_BearerConfig));
}
DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
- for(idx=0;idx<schReqList->list.count; idx++)
+ if(schedulingRequestConfig)
+ {
+ if(schReqList)
+ {
+ if(schReqList->list.array)
+ {
+ for(idx=0;idx<schReqList->list.count; idx++)
+ {
+ if(schReqList->list.array[idx])
+ {
+ DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
+ DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
+ }
+ }
+ DU_FREE(schReqList->list.array, schReqList->list.size);
+ }
+ DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
+ sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList)); }
+ DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
+ }
+
+ if(macCellGrpCfg->bsr_Config)
{
- DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
- DU_FREE(schReqList->list.array[idx], sizeof(SchedulingRequestId_t));
+ DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
}
- DU_FREE(schReqList->list.array, schReqList->list.size);
- DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
- sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
- DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
-
- DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
tagConfig = macCellGrpCfg->tag_Config;
tagList = tagConfig->tag_ToAddModList;
- for(idx=0; idx<tagList->list.count; idx++)
+ if(tagConfig)
{
- DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
- }
- DU_FREE(tagList->list.array, tagList->list.size);
- DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
+ if(tagList)
+ {
+ if(tagList->list.array)
+ {
+ for(idx=0; idx<tagList->list.count; idx++)
+ {
+ DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
+ }
+ DU_FREE(tagList->list.array, tagList->list.size);
+ }
+ DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
+ }
DU_FREE(tagConfig, sizeof(struct TAG_Config));
+ }
phrConfig = macCellGrpCfg->phr_Config;
- DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
- DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
+ if(phrConfig)
+ {
+ DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
+ DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
+ }
DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
}
{
DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
-
}
spCellCfg = cellGrpCfg->spCellConfig;
if(spCellCfg)
{
DU_FREE(spCellCfg->servCellIndex, sizeof(long));
- DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
+ DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
srvCellCfg = spCellCfg->spCellConfigDedicated;
-
- 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));
+ if(srvCellCfg)
+ {
+ 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));
}
-
return ROK;
}
/*******************************************************************
{
CellGroupConfigRrc_t cellGrpCfg;
asn_enc_rval_t encRetVal;
-
+ uint8_t ret = RFAILED;
while(1)
{
- duToCuRrcContainer = NULLP;
cellGrpCfg.cellGroupId = CELL_GRP_ID;
cellGrpCfg.rlc_BearerToAddModList = NULLP;
break;
}
- cellGrpCfg.rlc_BearerToReleaseList = NULLP;
+ cellGrpCfg.rlc_BearerToReleaseList = NULLP;
cellGrpCfg.mac_CellGroupConfig = NULLP;
DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
if(!cellGrpCfg.mac_CellGroupConfig)
break;
}
+ cellGrpCfg.sCellToAddModList = NULLP;
+ cellGrpCfg.sCellToReleaseList = NULLP;
+ cellGrpCfg.ext1 = NULLP;
+
/* encode cellGrpCfg into duToCuRrcContainer */
xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
}
}
- memcpy(duToCuRrcContainer, encBuf, encBufSize);
+ duToCuRrcContainer->size = encBufSize;
+ DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
+ if(!duToCuRrcContainer->buf)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildDuToCuRrcContainer");
+ break;
+ }
+ memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
+ ret = ROK;
break;
}
- FreeMemDuToCuRrcCont(&cellGrpCfg);
- return ROK;
+ FreeMemDuToCuRrcCont(&cellGrpCfg);
+ return ret;
}
/*******************************************************************
InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
initULRRCMsg =\
&f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
- elementCnt = 3;
+ elementCnt = 5;
initULRRCMsg->protocolIEs.list.count = elementCnt;
initULRRCMsg->protocolIEs.list.size = \
elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
initULRRCMsg->protocolIEs.list.array[idx1]->value.present =\
InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
- BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer);
+ ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer);
+ if(ret != ROK)
+ {
+ break;
+ }
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
+
/* Encode the F1SetupRequest type as APER */
cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
if(encRetVal.encoded == ENCODE_FAIL)
{
DU_LOG( "\n F1AP : Could not encode Initial UL RRC Message Transfer\
- structure (at %s)\n",encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ structure (at %s)\n",encRetVal.failed_type ? \
+ encRetVal.failed_type->name : "unknown");
break;
}
else
DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
}
+
+ idx1 = 4;
+ if(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer.buf)
+ {
+ DU_FREE(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer.buf,
+ initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.DUtoCURRCContainer.size);
+ }
for(ieId=0; ieId<elementCnt; ieId++)
{
DU_FREE(initULRRCMsg->protocolIEs.list.array[ieId],sizeof(InitialULRRCMessageTransferIEs_t));