X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_f1ap_msg_hdl.c;h=d63c8ad99c20f10917abb71fb348997159636ae7;hb=4d45b914f9e94203603d3b9fdbcb1aad361301dd;hp=3dc1763f8f615a3b253fc60ea9664360965db5c9;hpb=c4b8f7a0c5c6491323c6a87b2d1031d61ee0188e;p=o-du%2Fl2.git diff --git a/src/du_app/du_f1ap_msg_hdl.c b/src/du_app/du_f1ap_msg_hdl.c index 3dc1763f8..d63c8ad99 100644 --- a/src/du_app/du_f1ap_msg_hdl.c +++ b/src/du_app/du_f1ap_msg_hdl.c @@ -17,11 +17,17 @@ *******************************************************************************/ /* This file contains F1AP message handler functions */ - -#include "du_mgr.h" +#include "common_def.h" +#include "lrg.h" +#include "legtp.h" +#include "lkw.x" +#include "lrg.x" +#include "du_app_mac_inf.h" +#include "du_cfg.h" +#include "du_app_rlc_inf.h" +#include "E2AP-PDU.h" #include "du_mgr_main.h" -#include "du_cell_mgr.h" -#include "du_f1ap_msg_hdl.h" +#include "du_utils.h" #include "GNB-DU-System-Information.h" #include "CellGroupConfigRrc.h" #include "MAC-CellGroupConfig.h" @@ -51,17 +57,30 @@ #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 +#include "ProtocolExtensionField.h" +#include "F1AP-PDU.h" +#include "odu_common_codec.h" +#include "du_mgr.h" +#include "du_f1ap_msg_hdl.h" +uint8_t 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 ServedCellListreturn=RFAILED; -S16 sctpSend(Buffer *mBuf, U8 itfType); +uint8_t sctpSend(Buffer *mBuf, U8 itfType); uint8_t Nrcgiret=RFAILED; uint8_t SplCellListret=RFAILED; uint8_t SRBSetupret=RFAILED; @@ -667,26 +686,26 @@ uint8_t SendF1APMsg(Region region, Pool pool) { Buffer *mBuf; - if(SGetMsg(region, pool, &mBuf) == ROK) + if(ODU_GET_MSG(region, pool, &mBuf) == ROK) { - if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK) + if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK) { - SPrntMsg(mBuf, 0,0); + ODU_PRINT_MSG(mBuf, 0,0); if(sctpSend(mBuf, F1_INTERFACE) != ROK) { DU_LOG("\nF1AP : SCTP Send failed"); - SPutMsg(mBuf); + ODU_PUT_MSG(mBuf); return RFAILED; } } else { - DU_LOG("\nF1AP : SAddPstMsgMult failed"); - SPutMsg(mBuf); + DU_LOG("\nF1AP : ODU_ADD_POST_MSG_MULT failed"); + ODU_PUT_MSG(mBuf); return RFAILED; } - SPutMsg(mBuf); + ODU_PUT_MSG(mBuf); } else { @@ -1129,7 +1148,7 @@ uint8_t BuildAndSendF1SetupReq() xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg); /* Encode the F1SetupRequest type as APER */ - cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); + memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); encBufSize = 0; encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\ encBuf); @@ -1159,7 +1178,7 @@ uint8_t BuildAndSendF1SetupReq() ret=ROK; break; - }while(1); + }while(true); FreeF1SetupReq(f1apMsg); @@ -1203,7 +1222,7 @@ uint8_t BuildAndSendDUConfigUpdate() uint8_t ret= RFAILED; uint8_t i; - while(1) + while(true) { DU_LOG("\nF1AP : Building DU config update\n"); /* Allocate the memory for F1DuCfg */ @@ -1605,7 +1624,7 @@ uint8_t BuildAndSendDUConfigUpdate() xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg); /* Encode the DU Config Update type as APER */ - cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); + memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); encBufSize = 0; encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf); @@ -1916,6 +1935,12 @@ void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg) { if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP) { + if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present == + ULRRCMessageTransferIEs__value_PR_RRCContainer) + { + DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, + ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size); + } DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t)); } } @@ -1943,124 +1968,135 @@ void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg) * RFAILED - failure * * ****************************************************************/ -uint8_t BuildAndSendULRRCMessageTransfer() +uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb ueCb, uint8_t lcId, \ + uint16_t msgLen, uint8_t *rrcMsg) { - uint8_t elementCnt; - uint8_t idx1; - uint8_t idx; - F1AP_PDU_t *f1apMsg = NULL; + uint8_t elementCnt; + uint8_t idx1; + uint8_t idx; + F1AP_PDU_t *f1apMsg = NULL; ULRRCMessageTransfer_t *ulRRCMsg; - asn_enc_rval_t encRetVal; /* Encoder return value */ + asn_enc_rval_t encRetVal; /* Encoder return value */ uint8_t ret =RFAILED; - while(1) - { - DU_LOG("\n F1AP : Building UL RRC Message Transfer Message\n"); + while(true) + { + DU_LOG("\n F1AP : Building UL RRC Message Transfer Message\n"); - DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t)); - if(f1apMsg == NULLP) - { - DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed"); - break; - } + DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t)); + if(f1apMsg == NULLP) + { + DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed"); + break; + } - f1apMsg->present = F1AP_PDU_PR_initiatingMessage; - DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t)); - if(f1apMsg->choice.initiatingMessage == NULLP) - { - DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed"); - break; - } - f1apMsg->choice.initiatingMessage->procedureCode = \ - ProcedureCode_id_ULRRCMessageTransfer; - f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore; - f1apMsg->choice.initiatingMessage->value.present = \ - InitiatingMessage__value_PR_ULRRCMessageTransfer; - ulRRCMsg = - &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer; - elementCnt = 3; - ulRRCMsg->protocolIEs.list.count = elementCnt; - ulRRCMsg->protocolIEs.list.size = \ - elementCnt * sizeof(ULRRCMessageTransferIEs_t *); - - /* Initialize the F1Setup members */ - DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size); - if(ulRRCMsg->protocolIEs.list.array == NULLP) - { - DU_LOG(" F1AP : Memory allocation for UL RRC MessageTransferIEs failed"); - break; - } - for(idx=0; idxprotocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t)); - if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP) - { - break; - } - } + f1apMsg->present = F1AP_PDU_PR_initiatingMessage; + DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t)); + if(f1apMsg->choice.initiatingMessage == NULLP) + { + DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed"); + break; + } + f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer; + f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore; + f1apMsg->choice.initiatingMessage->value.present = \ + InitiatingMessage__value_PR_ULRRCMessageTransfer; + ulRRCMsg = + &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer; + elementCnt = 4; + ulRRCMsg->protocolIEs.list.count = elementCnt; + ulRRCMsg->protocolIEs.list.size = \ + elementCnt * sizeof(ULRRCMessageTransferIEs_t *); - idx1 = 0; + /* Initialize the F1Setup members */ + DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size); + if(ulRRCMsg->protocolIEs.list.array == NULLP) + { + DU_LOG(" F1AP : Memory allocation for UL RRC MessageTransferIEs failed"); + break; + } + for(idx=0; idxprotocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t)); + if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP) + { + break; + } + } - /*GNB CU UE F1AP ID*/ - ulRRCMsg->protocolIEs.list.array[idx1]->id = \ - ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID; - ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject; - ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \ - ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID; - ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID; - - /*GNB DU UE F1AP ID*/ - idx1++; - ulRRCMsg->protocolIEs.list.array[idx1]->id = \ - ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID; - ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject; - ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \ - ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID; - ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID; - - /*SRBID*/ - idx1++; - ulRRCMsg->protocolIEs.list.array[idx1]->id = \ - ProtocolIE_ID_id_SRBID; - ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject; - ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \ - ULRRCMessageTransferIEs__value_PR_SRBID; - ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = UL_SRBID; - - /*RRCContainer*/ - //YET TO FILL - - xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg); - - /* Encode the F1SetupRequest type as APER */ - cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); - encBufSize = 0; - encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\ - encBuf); - /* Encode results */ - if(encRetVal.encoded == ENCODE_FAIL) - { - DU_LOG( "\n F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\ - encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); - break; - } - else - { - DU_LOG("\n F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n"); - for(int i=0; i< encBufSize; i++) - { - printf("%x",encBuf[i]); - } - } + idx1 = 0; + + /*GNB CU UE F1AP ID*/ + ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID; + ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject; + ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \ + ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID; + ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId; + + /*GNB DU UE F1AP ID*/ + idx1++; + ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID; + ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject; + ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \ + ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID; + ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId; + + /*SRBID*/ + idx1++; + ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID; + ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject; + ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \ + ULRRCMessageTransferIEs__value_PR_SRBID; + ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId; + + /*RRCContainer*/ + idx1++; + ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCContainer; + ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject; + ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \ + ULRRCMessageTransferIEs__value_PR_RRCContainer; + ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen; + DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, + ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size) + if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf) + { + DU_LOG(" F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed"); + break; + } + memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \ + rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size); - /* Sending msg */ - if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK) - { - DU_LOG("\n F1AP : Sending UL RRC Message Transfer Failed"); - break; - } + xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg); + + /* Encode the F1SetupRequest type as APER */ + memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\ + encBuf); + /* Encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG( "\n F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\n F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n"); + for(int i=0; i< encBufSize; i++) + { + printf("%x",encBuf[i]); + } + } + + /* Sending msg */ + if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK) + { + DU_LOG("\n F1AP : Sending UL RRC Message Transfer Failed"); + break; + } ret = ROK; - break; - } + break; + } FreeULRRCMessageTransfer(f1apMsg); return ret; @@ -2492,10 +2528,11 @@ struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList { uint8_t idx; uint8_t elementCnt; - uint8_t numBytes; - uint8_t byteIdx; - uint8_t bitsUnused; + uint8_t numBytes, bitsUnused; struct ControlResourceSet *controlRSet; + uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0}; + uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb; + elementCnt = 1; controlRSetList->list.count = elementCnt; @@ -2512,7 +2549,7 @@ struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList for(idx = 0; idx < elementCnt; idx++) { - controlRSetList->list.array[idx] = NULLP; + controlRSetList->list.array[idx] = NULLP; DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet)); if(!controlRSetList->list.array[idx]) { @@ -2531,7 +2568,7 @@ struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList * 3 LSBs unsued * Bit string stored ff0000000000 */ - numBytes = 6; + numBytes = 6; bitsUnused = 3; controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t); @@ -2543,13 +2580,15 @@ struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList"); return RFAILED; } - byteIdx = 0; - controlRSet->frequencyDomainResources.buf[byteIdx] = 255; /* setting 8 MSBs i.e. ff */ - for(byteIdx = 1; byteIdx < numBytes; byteIdx++) - { - controlRSet->frequencyDomainResources.buf[byteIdx] = 0; - } - controlRSet->frequencyDomainResources.bits_unused = bitsUnused; + + memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE); + coreset0EndPrb = CORESET0_END_PRB; + coreset1StartPrb = coreset0EndPrb + 6; + coreset1NumPrb = CORESET1_NUM_PRB; + /* calculate the PRBs */ + schAllocFreqDomRscType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource); + memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE); + controlRSet->frequencyDomainResources.bits_unused = bitsUnused; controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION; controlRSet->cce_REG_MappingType.present = \ @@ -2720,7 +2759,8 @@ struct PDCCH_Config__searchSpacesToAddModList *searchSpcList } byteIdx = 0; - searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 128 /* setting MSB to 128 i.e. 0x80 */; + 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; @@ -3396,6 +3436,262 @@ uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg) 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 @@ -3414,6 +3710,8 @@ uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg) 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) @@ -3437,7 +3735,30 @@ uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp) } 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; @@ -3656,7 +3977,6 @@ uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg) DU_LOG("\nF1AP : BuildInitialDlBWP failed"); return RFAILED; } - srvCellCfg->downlinkBWP_ToReleaseList = NULLP; srvCellCfg->downlinkBWP_ToAddModList = NULLP; @@ -3693,7 +4013,6 @@ uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg) DU_LOG("\nF1AP : BuildUlCfg failed"); return RFAILED; } - srvCellCfg->supplementaryUplink = NULLP; srvCellCfg->pdcch_ServingCellConfig = NULLP; @@ -3909,6 +4228,458 @@ uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg) 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 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; idx1choice.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 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)); + } +} /******************************************************************* * @@ -3918,7 +4689,7 @@ uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg) * * Function : FreeMemDuToCuRrcCont * - * Functionality: Builds DuToCuRrcContainer + * Functionality: Deallocating memory of DuToCuRrcContainer * * @params[in] DuToCuRRCContainer, DuToCuRRCContainer * @@ -3928,19 +4699,21 @@ uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg) * ****************************************************************/ 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) @@ -3949,30 +4722,33 @@ uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg) { for(idx=0; idxlist.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); } @@ -3983,11 +4759,10 @@ uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg) if(macCellGrpCfg) { schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig; - schReqList = schedulingRequestConfig->schedulingRequestToAddModList; - if(schedulingRequestConfig) { - if(schReqList) + schReqList = schedulingRequestConfig->schedulingRequestToAddModList; + if(schReqList) { if(schReqList->list.array) { @@ -4005,17 +4780,15 @@ uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg) 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) { @@ -4027,7 +4800,7 @@ uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg) } 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; @@ -4050,21 +4823,59 @@ uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg) 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; } @@ -4091,7 +4902,7 @@ uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer) asn_enc_rval_t encRetVal; uint8_t ret = RFAILED; - while(1) + while(true) { cellGrpCfg.cellGroupId = CELL_GRP_ID; @@ -4155,7 +4966,7 @@ uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer) /* encode cellGrpCfg into duToCuRrcContainer */ xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg); - cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); + memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); encBufSize = 0; encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf); /* Encode results */ @@ -4207,7 +5018,7 @@ uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer) * * ****************************************************************/ uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti, - uint8_t *rrcContainer) + uint16_t rrcContSize, uint8_t *rrcContainer) { uint8_t ret; uint8_t elementCnt; @@ -4218,7 +5029,7 @@ uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP; asn_enc_rval_t encRetVal; bool checkvar=false; - while(1) + while(true) { DU_LOG("\n F1AP : Building RRC Setup Request\n"); DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t)); @@ -4304,18 +5115,17 @@ uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti initULRRCMsg->protocolIEs.list.array[idx1]->value.present =\ InitialULRRCMessageTransferIEs__value_PR_RRCContainer; - initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size =\ - strlen((const char*)rrcContainer); - DU_ALLOC(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, - initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size) + initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = rrcContSize; + DU_ALLOC(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, + initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size) if(!initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf) { - DU_LOG(" F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed"); + DU_LOG(" F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed"); break; } - memcpy(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, rrcContainer, - initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size); + memcpy(initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, rrcContainer, + initULRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size); /*DUtoCURRCContainer*/ @@ -4335,7 +5145,7 @@ uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg); /* Encode the F1SetupRequest type as APER */ - cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); + memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); encBufSize = 0; encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf); /* Encode results */ @@ -5261,7 +6071,7 @@ uint8_t BuildAndSendUESetReq() asn_enc_rval_t encRetVal; /* Encoder return value */ uint8_t ret= RFAILED; uint8_t ret1; - while(1) + while(true) { DU_LOG("\n F1AP : Building UE Context Setup Request\n"); @@ -5411,7 +6221,7 @@ uint8_t BuildAndSendUESetReq() xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg); /* Encode the F1SetupRequest type as APER */ - cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); + memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN); encBufSize = 0; encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\ encBuf); @@ -5473,16 +6283,18 @@ void F1APMsgHdlr(Buffer *mBuf) F1AP_PDU_t f1apasnmsg ; DU_LOG("\nF1AP : Received F1AP message buffer"); - SPrntMsg(mBuf, 0,0); + ODU_PRINT_MSG(mBuf, 0,0); /* Copy mBuf into char array to decode it */ - SFndLenMsg(mBuf, &recvBufLen); - if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK) + ODU_FIND_MSG_LEN(mBuf, &recvBufLen); + DU_ALLOC(recvBuf, (Size)recvBufLen); + + if(recvBuf == NULLP) { DU_LOG("\nF1AP : Memory allocation failed"); return; } - if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK) + if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK) { DU_LOG("\nF1AP : Failed while copying %d", copyCnt); return; @@ -5499,7 +6311,8 @@ void F1APMsgHdlr(Buffer *mBuf) memset(f1apMsg, 0, sizeof(F1AP_PDU_t)); rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0); - SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen); + DU_FREE(recvBuf, (Size)recvBufLen); + if(rval.code == RC_FAIL || rval.code == RC_WMORE) { DU_LOG("\nF1AP : ASN decode failed");