From: lal.harshita Date: Thu, 30 Mar 2023 12:36:41 +0000 (+0530) Subject: [Task-ID: ODUHIGH-502] Fixes in F1 Setup Request message building X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?p=o-du%2Fl2.git;a=commitdiff_plain;h=d1086166f17ae851cba5296a7ce1c5c5d1a553b9 [Task-ID: ODUHIGH-502] Fixes in F1 Setup Request message building Signed-off-by: lal.harshita Change-Id: Ib6c34a5edb3f43bdf873c01d50176bee2a8ef840 Signed-off-by: lal.harshita --- diff --git a/src/cm/common_def.c b/src/cm/common_def.c index 5aa8705e5..11d80b2d7 100644 --- a/src/cm/common_def.c +++ b/src/cm/common_def.c @@ -228,11 +228,11 @@ uint8_t convertScsValToScsEnum(uint32_t num) } /******************************************************************* - * @brief convert scs periodicity value into the enum value received from O1 + * @brief convert SSB periodicity value into the enum value received from O1 * * @details * - * Function : convertScsPeriodicityToEnum + * Function : convertSSBPeriodicityToEnum * * Functionality: * - convert scs periodicity value @@ -242,30 +242,30 @@ uint8_t convertScsValToScsEnum(uint32_t num) * RFAILED - failure * * ****************************************************************/ -uint8_t convertScsPeriodicityToEnum(uint32_t num) +uint8_t convertSSBPeriodicityToEnum(uint32_t num) { switch(num) { case 5: - return SCS_5MS; + return SSB_5MS; case 10: - return SCS_10MS; + return SSB_10MS; case 20: - return SCS_20MS; + return SSB_20MS; case 40: - return SCS_40MS; + return SSB_40MS; case 80: - return SCS_80MS; + return SSB_80MS; case 160: - return SCS_160MS; + return SSB_160MS; default: - return SCS_5MS; + return SSB_5MS; } } /******************************************************************* diff --git a/src/cm/common_def.h b/src/cm/common_def.h index ae50d82b5..1bdb4a118 100644 --- a/src/cm/common_def.h +++ b/src/cm/common_def.h @@ -275,13 +275,13 @@ typedef enum typedef enum { - SCS_5MS, - SCS_10MS, - SCS_20MS, - SCS_40MS, - SCS_80MS, - SCS_160MS -}ScsPeriodicity; + SSB_5MS, + SSB_10MS, + SSB_20MS, + SSB_40MS, + SSB_80MS, + SSB_160MS +}SSBPeriodicity; typedef enum { @@ -351,7 +351,7 @@ void oduCpyFixBufToMsg(uint8_t *fixBuf, Buffer *mBuf, uint16_t len); uint8_t buildPlmnId(Plmn plmn, uint8_t *buf); uint16_t convertScsEnumValToScsVal(uint8_t scsEnumValue); uint8_t convertScsValToScsEnum(uint32_t num); -uint8_t convertScsPeriodicityToEnum(uint32_t num); +uint8_t convertSSBPeriodicityToEnum(uint32_t num); uint8_t SGetSBufNewForDebug(char *file, const char *func, int line, Region region, Pool pool, Data **ptr, Size size); uint8_t SPutSBufNewForDebug(char *file, const char *func, int line, Region region, Pool pool, Data *ptr, Size size); diff --git a/src/du_app/du_cfg.c b/src/du_app/du_cfg.c index 0daca41ab..01b67c5b1 100644 --- a/src/du_app/du_cfg.c +++ b/src/du_app/du_cfg.c @@ -176,7 +176,7 @@ uint8_t readMacCfg() duCfgParam.macCellCfg.ssbCfg.betaPss = BETA_PSS; #ifdef O1_ENABLE duCfgParam.macCellCfg.ssbCfg.scsCmn = convertScsValToScsEnum(cellParams.ssbSubCarrierSpacing); - duCfgParam.macCellCfg.ssbCfg.ssbPeriod = convertScsPeriodicityToEnum(cellParams.ssbPeriodicity); + duCfgParam.macCellCfg.ssbCfg.ssbPeriod = convertSSBPeriodicityToEnum(cellParams.ssbPeriodicity); duCfgParam.macCellCfg.ssbCfg.ssbScOffset = cellParams.ssbOffset; #else duCfgParam.macCellCfg.ssbCfg.scsCmn = NR_SCS; @@ -646,8 +646,15 @@ uint8_t readCfg() duCfgParam.egtpParams.maxTunnelId = MAX_TEID; duCfgParam.maxUe = 32; //TODO: Check - /* DU Info */ - duCfgParam.duId = DU_ID; + + /* DU Info */ + duCfgParam.duId = DU_ID; + DU_ALLOC(duCfgParam.duName, sizeof(DU_NAME)); + if(!duCfgParam.duName) + { + DU_LOG("\nDEBUG --> DU_APP: readCfg(): Memory allocation failure for DU name"); + return RFAILED; + } strcpy((char*)duCfgParam.duName,DU_NAME); /* Mib Params */ @@ -662,8 +669,7 @@ uint8_t readCfg() mib.controlResourceSetZero = CORESET_0_INDEX; mib.searchSpaceZero = SEARCHSPACE_0_INDEX; mib.cellBarred = MIB__cellBarred_notBarred; - mib.intraFreqReselection = - MIB__intraFreqReselection_notAllowed; + mib.intraFreqReselection = MIB__intraFreqReselection_notAllowed; duCfgParam.mibParams = mib; /* SIB1 Params */ @@ -678,7 +684,7 @@ uint8_t readCfg() #ifdef O1_ENABLE sib1.tac = cellParams.nRTAC; sib1.cellIdentity = CELL_IDENTITY * cellParams.cellLocalId; - DU_LOG("\n*********DEBUG --> DU_APP: readCfg(): OAM CellLocalId=%d", \ + DU_LOG("\nDEBUG --> DU_APP: readCfg(): OAM CellLocalId=%d", \ sib1.cellIdentity); #else sib1.tac = DU_TAC; @@ -686,7 +692,8 @@ uint8_t readCfg() #endif sib1.cellResvdForOpUse = PLMN_IdentityInfo__cellReservedForOperatorUse_notReserved; sib1.connEstFailCnt = ConnEstFailureControl__connEstFailCount_n3; - sib1.connEstFailOffValidity = ConnEstFailureControl__connEstFailOffsetValidity_s120; + sib1.connEstFailOffValidity = ConnEstFailureControl__connEstFailOffsetValidity_s900; + sib1.connEstFailOffset = 15; sib1.siSchedInfo.winLen = SI_SchedulingInfo__si_WindowLength_s5; sib1.siSchedInfo.broadcastSta = SchedulingInfo__si_BroadcastStatus_broadcasting; sib1.siSchedInfo.preiodicity = SchedulingInfo__si_Periodicity_rf8; @@ -795,13 +802,13 @@ uint8_t readCfg() #ifdef O1_ENABLE duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn = cellParams.arfcnUL; duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulArfcn = cellParams.arfcnSUL; - duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs = convertScsPeriodicityToEnum(cellParams.ssbPeriodicity); + duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs = cellParams.ssbSubCarrierSpacing; #else duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn = NR_UL_ARFCN; duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulArfcn = SUL_ARFCN; - duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs = SSB_PRDCTY_MS_20; + duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs = NR_SCS; #endif - duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb = NRB_106; + duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb = NRB_273; for(freqBandIdx=0; freqBandIdxfreqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\ f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand; + freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt; freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\ supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*); @@ -824,6 +829,186 @@ uint8_t BuildServedPlmn(ServedPLMNs_List_t *srvplmn) } return ROK; } + +/******************************************************************* + * + * @brief Frees Measurement Timing configuration + * + * @details + * + * Function : FreeMeasTimingConf + * + * Functionality: Frees Timing Configuration + * + * @params[in] MeasurementTimingConfigurationRrc_t measTimingConfRrc + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void FreeMeasTimingConf(MeasurementTimingConfigurationRrc_t measTimingConfRrc) +{ + uint8_t measIeIdx = 0; + MeasurementTimingConfigurationRrc_IEs_t *measTimingConfIEs = NULLP; + + if(measTimingConfRrc.criticalExtensions.choice.c1) + { + if(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf) + { + measTimingConfIEs = measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf; + if(measTimingConfIEs->measTiming) + { + if(measTimingConfIEs->measTiming->list.array) + { + for(measIeIdx = 0; measIeIdx < measTimingConfIEs->measTiming->list.count; measIeIdx++) + { + if(measTimingConfIEs->measTiming->list.array[measIeIdx]) + { + DU_FREE(measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming)); + DU_FREE(measTimingConfIEs->measTiming->list.array[measIeIdx], sizeof(MeasTiming_t)); + } + } + DU_FREE(measTimingConfIEs->measTiming->list.array, measTimingConfIEs->measTiming->list.size); + } + DU_FREE(measTimingConfIEs->measTiming, sizeof(MeasTimingList_t)); + } + DU_FREE(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(MeasurementTimingConfigurationRrc_IEs_t)); + } + DU_FREE(measTimingConfRrc.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1)); + } +} + +/******************************************************************* + * + * @brief Builds MEasuerment Timing Configuration + * + * @details + * + * Function : BuildMeasTimingConf + * + * Functionality: Building Measurement Timing Configuration + * + * @params[in] Pointer to octet string to store Measurement timing + * Configuration + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t BuildMeasTimingConf(OCTET_STRING_t *measTimingConf) +{ + uint8_t ret = RFAILED; + uint8_t elementCnt = 0; + uint8_t measIeIdx = 0; + asn_enc_rval_t encRetVal; + MeasurementTimingConfigurationRrc_t measTimingConfRrc; + MeasurementTimingConfigurationRrc_IEs_t *measTimingConfIEs = NULLP; + struct MeasTiming__frequencyAndTiming *freqAndTiming = NULLP; + + while(true) + { + measTimingConfRrc.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1; + DU_ALLOC(measTimingConfRrc.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1)); + if(!measTimingConfRrc.criticalExtensions.choice.c1) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for critical extension choice C1"); + break; + } + measTimingConfRrc.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf; + + DU_ALLOC(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(MeasurementTimingConfigurationRrc_IEs_t)); + if(!measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for measTimingConf"); + break; + } + measTimingConfIEs = measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf; + + DU_ALLOC(measTimingConfIEs->measTiming, sizeof(MeasTimingList_t)); + if(!measTimingConfIEs->measTiming) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList"); + break; + } + + elementCnt = 1; + measTimingConfIEs->measTiming->list.count = elementCnt; + measTimingConfIEs->measTiming->list.size = elementCnt * sizeof(MeasTiming_t *); + DU_ALLOC(measTimingConfIEs->measTiming->list.array, measTimingConfIEs->measTiming->list.size); + if(!measTimingConfIEs->measTiming->list.array) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList array"); + break; + } + + for(measIeIdx = 0; measIeIdx < elementCnt; measIeIdx++) + { + DU_ALLOC(measTimingConfIEs->measTiming->list.array[measIeIdx], sizeof(MeasTiming_t)); + if(!measTimingConfIEs->measTiming->list.array[measIeIdx]) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList array index %d", measIeIdx); + break; + } + } + if(measIeIdx < elementCnt) + { + break; + } + + measIeIdx = 0; + DU_ALLOC(measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming)); + if(!measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming) + { + DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for frequencyAndTiming"); + break; + } + freqAndTiming = measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming; + freqAndTiming->carrierFreq = MEAS_TIMING_ARFCN; + freqAndTiming->ssbSubcarrierSpacing = duCfgParam.macCellCfg.ssbCfg.scsCmn; + freqAndTiming->ssb_MeasurementTimingConfiguration.periodicityAndOffset.present = duCfgParam.macCellCfg.ssbCfg.ssbPeriod + 1; + freqAndTiming->ssb_MeasurementTimingConfiguration.periodicityAndOffset.choice.sf20 = duCfgParam.macCellCfg.ssbCfg.ssbScOffset; + freqAndTiming->ssb_MeasurementTimingConfiguration.duration = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfgDuration; + + /* Encode the F1SetupRequest type as APER */ + xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfRrc); + + memset(encBuf, 0, ENC_BUF_MAX_LEN); + encBufSize = 0; + encRetVal = uper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfRrc, PrepFinalEncBuf, encBuf); + + /* Encode results */ + if(encRetVal.encoded == ENCODE_FAIL) + { + DU_LOG("\nERROR --> F1AP : Could not encode Measurement Timing Configuration structure (at %s)\n",\ + encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); + break; + } + else + { + DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Measurement Timing Configuration \n"); +#ifdef DEBUG_ASN_PRINT + for(measIeIdx=0; measIeIdx< encBufSize; measIeIdx++) + { + printf("%x",encBuf[measIeIdx]); + } +#endif + + measTimingConf->size = encBufSize; + DU_ALLOC(measTimingConf->buf, encBufSize); + if(measTimingConf->buf == NULLP) + { + DU_LOG("\nERROR --> F1AP : Memory allocation failed for MeasurementTimingConfiguration buffer"); + return RFAILED; + } + memcpy(measTimingConf->buf, &encBuf, encBufSize); + + FreeMeasTimingConf(measTimingConfRrc); + + ret = ROK; + break; + } + } + return ret; +} + /******************************************************************* * * @brief Builds Served Cell List @@ -884,36 +1069,30 @@ uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell) srvCellItem->served_Cell_Information.nRPCI = \ duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci; - /*fiveGS_TAC*/ + /* fiveGS_TAC */ BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information); if(BuildFiveGSTacret != ROK) { return RFAILED; } - /*Served PLMNs*/ + + /* Served PLMNs */ BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs); if(BuildServedPlmnret !=ROK) { return RFAILED; } - /*nR Mode Info with FDD*/ + + /* nR Mode Info with FDD/TDD */ BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info); if(BuildNrModeret != ROK) { return RFAILED; } + /*Measurement timing Config*/ - srvCellItem->served_Cell_Information.measurementTimingConfiguration.\ - size = sizeof(uint8_t); - DU_ALLOC(srvCellItem->served_Cell_Information.\ - measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size); - if(srvCellItem->served_Cell_Information.\ - measurementTimingConfiguration.buf == NULLP) - { + if(BuildMeasTimingConf(&srvCellItem->served_Cell_Information.measurementTimingConfiguration) != ROK) return RFAILED; - } - srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \ - duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg; /* GNB DU System Information */ DU_ALLOC(srvCellItem->gNB_DU_System_Information, @@ -1359,50 +1538,51 @@ void FreeF1SetupReq(F1AP_PDU_t *f1apMsg) { if(f1apMsg->choice.initiatingMessage != NULLP) { - f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest; - if(f1SetupReq->protocolIEs.list.array != NULLP) - { - for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++) - { - if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP) - { - switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id) - { - case ProtocolIE_ID_id_TransactionID: - break; - case ProtocolIE_ID_id_gNB_DU_ID: - DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\ - f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size); - break; - case ProtocolIE_ID_id_gNB_DU_Name: - DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\ - strlen((char *)duCfgParam.duName)); - break; - case ProtocolIE_ID_id_gNB_DU_Served_Cells_List: - FreeServedCellList(&f1SetupReq->protocolIEs.list.\ - array[ieIdx]->value.choice.GNB_DU_Served_Cells_List); - break; - case ProtocolIE_ID_id_GNB_DU_RRC_Version: - FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version); - break; - default: - DU_LOG("\nERROR --> Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id); - break; - } - } - } - for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++) - { - DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t)); - } - DU_FREE(f1SetupReq->protocolIEs.list.array,\ - f1SetupReq->protocolIEs.list.size); - } - DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t)); + f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest; + if(f1SetupReq->protocolIEs.list.array != NULLP) + { + for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++) + { + if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP) + { + switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id) + { + case ProtocolIE_ID_id_TransactionID: + break; + case ProtocolIE_ID_id_gNB_DU_ID: + DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\ + f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size); + break; + case ProtocolIE_ID_id_gNB_DU_Name: + DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\ + strlen((char *)duCfgParam.duName)); + break; + case ProtocolIE_ID_id_gNB_DU_Served_Cells_List: + FreeServedCellList(&f1SetupReq->protocolIEs.list.\ + array[ieIdx]->value.choice.GNB_DU_Served_Cells_List); + break; + case ProtocolIE_ID_id_GNB_DU_RRC_Version: + FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version); + break; + default: + DU_LOG("\nERROR --> Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id); + break; + } + } + } + for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++) + { + DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t)); + } + DU_FREE(f1SetupReq->protocolIEs.list.array,\ + f1SetupReq->protocolIEs.list.size); + } + DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t)); } DU_FREE(f1apMsg, sizeof(F1AP_PDU_t)); } } + /******************************************************************* * * @brief Builds and Send the F1SetupRequest @@ -1433,22 +1613,22 @@ uint8_t BuildAndSendF1SetupReq() DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t)); if(f1apMsg == NULLP) { - break; + break; } f1apMsg->present = F1AP_PDU_PR_initiatingMessage; DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t)); if(f1apMsg->choice.initiatingMessage == NULLP) { - break; + break; } f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup; f1apMsg->choice.initiatingMessage->criticality = Criticality_reject; f1apMsg->choice.initiatingMessage->value.present = \ - InitiatingMessage__value_PR_F1SetupRequest; + InitiatingMessage__value_PR_F1SetupRequest; f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest; - elementCnt = 4; + elementCnt = 5; f1SetupReq->protocolIEs.list.count = elementCnt; f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t ); @@ -1497,7 +1677,6 @@ uint8_t BuildAndSendF1SetupReq() f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\ duCfgParam.duId; -#if 0 /* DU name IE is of type printableString_t which wireshark is unable to decode. * However this string is decoded successfully on online decoders. * Since this is an optional IE and the value received in it are not @@ -1518,9 +1697,8 @@ uint8_t BuildAndSendF1SetupReq() break; } strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf, - (char*)&duCfgParam.duName); + (char*)duCfgParam.duName); } -#endif /*Served Cell list */ ieIdx++; @@ -1536,7 +1714,6 @@ uint8_t BuildAndSendF1SetupReq() break; } - /*RRC Version*/ ieIdx++; f1SetupReq->protocolIEs.list.array[ieIdx]->id = \ @@ -2142,15 +2319,8 @@ uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo) #endif /*Measurement timing Config*/ - srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t); - DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\ - buf,srvCellInfo->measurementTimingConfiguration.size); - if(srvCellInfo->measurementTimingConfiguration.buf == NULLP) - { + if(BuildMeasTimingConf(&srvCellInfo->measurementTimingConfiguration) != ROK) return RFAILED; - } - srvCellInfo->measurementTimingConfiguration.\ - buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg; return ROK; } diff --git a/src/du_app/du_sys_info_hdl.c b/src/du_app/du_sys_info_hdl.c index 7ce598fb5..0a830ea5e 100644 --- a/src/du_app/du_sys_info_hdl.c +++ b/src/du_app/du_sys_info_hdl.c @@ -54,6 +54,7 @@ #include "TDD-UL-DL-ConfigCommon.h" #include "ServingCellConfigCommonSIB.h" #include "MCC.h" +#include "BCCH-DL-SCH-Message.h" #include "SIB1.h" #include "odu_common_codec.h" #include "du_sys_info_hdl.h" @@ -452,6 +453,7 @@ uint8_t BuildPlmnList(CellAccessRelatedInfo_t *cellAccessInfo) DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure"); return RFAILED; } + elementCnt = cellAccessInfo->plmn_IdentityList.list.count; for(idx=0; idxplmn_IdentityList.list.array[idx]->\ - plmn_IdentityList; + plmnIdInfo = &cellAccessInfo->plmn_IdentityList.list.array[idx]->plmn_IdentityList; plmnIdInfo->list.count = elementCnt; plmnIdInfo->list.size = elementCnt * sizeof(PLMN_IdentitY_t *); DU_ALLOC(plmnIdInfo->list.array, plmnIdInfo->list.size); @@ -481,8 +482,7 @@ uint8_t BuildPlmnList(CellAccessRelatedInfo_t *cellAccessInfo) for(idx1=0; idx1list.array[idx1], - sizeof(PLMN_IdentitY_t)); + DU_ALLOC(plmnIdInfo->list.array[idx1], sizeof(PLMN_IdentitY_t)); if(!(plmnIdInfo->list.array[idx1])) { DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure"); @@ -490,8 +490,7 @@ uint8_t BuildPlmnList(CellAccessRelatedInfo_t *cellAccessInfo) } } idx1 = 0; - DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc, - sizeof(MCC_t)); + DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc, sizeof(MCC_t)); if(!plmnIdInfo->list.array[idx1]->mcc) { DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure"); @@ -500,15 +499,13 @@ uint8_t BuildPlmnList(CellAccessRelatedInfo_t *cellAccessInfo) elementCnt = ODU_VALUE_THREE; plmnIdInfo->list.array[idx1]->mcc->list.count = elementCnt; - plmnIdInfo->list.array[idx1]->mcc->list.size =\ - elementCnt * sizeof(MCC_MNC_Digit_t *); - DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc->list.array, - plmnIdInfo->list.array[idx1]->mcc->list.size) - if(!(plmnIdInfo->list.array[idx1]->mcc->list.array)) - { - DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure"); - return RFAILED; - } + plmnIdInfo->list.array[idx1]->mcc->list.size = elementCnt * sizeof(MCC_MNC_Digit_t *); + DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc->list.array, plmnIdInfo->list.array[idx1]->mcc->list.size); + if(!(plmnIdInfo->list.array[idx1]->mcc->list.array)) + { + DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure"); + return RFAILED; + } for(idx2=0; idx2list.array[idx1]->mcc->list.array[idx2], @@ -923,6 +920,12 @@ uint8_t BuildCommonSerachSpaceList( struct PDCCH_ConfigCommon__commonSearchSpace searchSpace->nrofCandidates->aggregationLevel8 = duPdcchCfg.numCandAggLvl8; searchSpace->nrofCandidates->aggregationLevel16 = duPdcchCfg.numCandAggLvl16; +/* Commented due to ASN decode failure in wireshark. + * Parameters like dci_Format0_0_AndFormat1_0 which are pointer to a structure that + * does not have any member parameter lead to decode failure in wireshark. + * The issue has been reported to Nokia. + * The following code will be uncommented once the issue is resolved */ +#if 0 /* Search Space type and DCI Format */ DU_ALLOC(searchSpace->searchSpaceType, sizeof( struct SearchSpace__searchSpaceType)); if(!searchSpace->searchSpaceType) @@ -973,6 +976,8 @@ uint8_t BuildCommonSerachSpaceList( struct PDCCH_ConfigCommon__commonSearchSpace return RFAILED; } } +#endif + return ROK; }/* BuildCommonSerachSpaceList */ @@ -2382,6 +2387,7 @@ uint8_t BuildServCellCfgCommonSib(ServingCellConfigCommonSIB_t *srvCellCfg) * ****************************************************************/ uint8_t BuildSib1Msg() { + BCCH_DL_SCH_Message_t bcchMsg; SIB1_t *sib1Msg; CellAccessRelatedInfo_t *cellAccessInfo; uint8_t elementCnt; @@ -2391,15 +2397,50 @@ uint8_t BuildSib1Msg() do { - DU_ALLOC(sib1Msg, sizeof(SIB1_t)); - if(!sib1Msg) + bcchMsg.message.present = BCCH_DL_SCH_MessageType_PR_c1; + + DU_ALLOC(bcchMsg.message.choice.c1, sizeof(struct BCCH_DL_SCH_MessageType__c1)); + if(!bcchMsg.message.choice.c1) + { + DU_LOG("\nERROR --> DU APP: BCCH-DL-SCH msg memory allocation failure"); + break; + } + bcchMsg.message.choice.c1->present = BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1; + DU_ALLOC(bcchMsg.message.choice.c1->choice.systemInformationBlockType1, sizeof(SIB1_t)); + if(!bcchMsg.message.choice.c1->choice.systemInformationBlockType1) { DU_LOG("\nERROR --> DU APP: SIB1 msg memory allocation failure"); break; } - + sib1Msg = bcchMsg.message.choice.c1->choice.systemInformationBlockType1; elementCnt = ODU_VALUE_ONE; + /* Cell Selection Info */ + DU_ALLOC(sib1Msg->cellSelectionInfo, sizeof(struct SIB1__cellSelectionInfo)); + if(!sib1Msg->cellSelectionInfo) + { + DU_LOG("\nERROR --> DU APP: SIB1 Cell Selection Info memory allocation failed"); + break; + } + + sib1Msg->cellSelectionInfo->q_RxLevMin = -50; + + DU_ALLOC(sib1Msg->cellSelectionInfo->q_RxLevMinSUL, sizeof(Q_RxLevMin_t)); + if(!sib1Msg->cellSelectionInfo->q_RxLevMinSUL) + { + DU_LOG("\nERROR --> DU APP: BuildSib1Msg(): Memory allocation failed for q_RxLevMinSUL"); + break; + } + *(sib1Msg->cellSelectionInfo->q_RxLevMinSUL) = -50; + + DU_ALLOC(sib1Msg->cellSelectionInfo->q_QualMin, sizeof(Q_QualMin_t)); + if(!sib1Msg->cellSelectionInfo->q_QualMin) + { + DU_LOG("\nERROR --> DU APP: BuildSib1Msg(): Memory allocation failed for q_QualMin"); + break; + } + *(sib1Msg->cellSelectionInfo->q_QualMin) = -30; + /* PLMN list */ cellAccessInfo = &sib1Msg->cellAccessRelatedInfo; cellAccessInfo->plmn_IdentityList.list.count = elementCnt; @@ -2417,10 +2458,16 @@ uint8_t BuildSib1Msg() DU_LOG("\nERROR --> DU APP: sib1Msg->connEstFailureControl memory allocation failure"); break; } - sib1Msg->connEstFailureControl->connEstFailCount =\ - duCfgParam.sib1Params.connEstFailCnt; - sib1Msg->connEstFailureControl->connEstFailOffsetValidity =\ - duCfgParam.sib1Params.connEstFailOffValidity; + sib1Msg->connEstFailureControl->connEstFailCount = duCfgParam.sib1Params.connEstFailCnt; + sib1Msg->connEstFailureControl->connEstFailOffsetValidity = duCfgParam.sib1Params.connEstFailOffValidity; + + DU_ALLOC(sib1Msg->connEstFailureControl->connEstFailOffset, sizeof(long)); + if(!sib1Msg->connEstFailureControl->connEstFailOffset) + { + DU_LOG("\nERROR --> DU APP: BuildSib1Msg(): Memory allocation failed for connEstFailOffset"); + break; + } + *(sib1Msg->connEstFailureControl->connEstFailOffset) = duCfgParam.sib1Params.connEstFailOffset; /* SI Scheduling Info */ DU_ALLOC(sib1Msg->si_SchedulingInfo, sizeof(SI_SchedulingInfo_t)); @@ -2453,17 +2500,17 @@ uint8_t BuildSib1Msg() break; } - xer_fprint(stdout, &asn_DEF_SIB1, sib1Msg); + xer_fprint(stdout, &asn_DEF_BCCH_DL_SCH_Message, &bcchMsg); /* Encode the F1SetupRequest type as APER */ memset(encBuf, 0, ENC_BUF_MAX_LEN); encBufSize = 0; - encRetVal = uper_encode(&asn_DEF_SIB1, 0, sib1Msg, PrepFinalEncBuf,\ + encRetVal = uper_encode(&asn_DEF_BCCH_DL_SCH_Message, 0, &bcchMsg, PrepFinalEncBuf,\ encBuf); printf("\nencbufSize: %d\n", encBufSize); if(encRetVal.encoded == -1) { - DU_LOG("\nERROR --> DU APP : Could not encode SIB1 structure (at %s)\n",\ + DU_LOG("\nERROR --> DU APP : Could not encode BCCH-DL-SCH structure (at %s)\n",\ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown"); @@ -2481,12 +2528,11 @@ uint8_t BuildSib1Msg() break; }while(true); - FreeSib1Msg(sib1Msg); + FreeBcchDlSchMsg(bcchMsg); return ret; - - } + /******************************************************************* * * @brief : deallocating the memory of BuildSib1Msg @@ -3205,6 +3251,40 @@ void FreeSib1Msg(SIB1_t *sib1Msg) } +/******************************************************************* + * + * @brief : Deallocation of BCCH_DL_SCH_Message_t + * + * @details + * + * Function : FreeBcchDlSchMsg + * + * Functionality: Freeing memory of BCCH DL SCH Message + * + * @params[in] : BCCH_DL_SCH_Message_t bcchMsg + * @return : void + * + *******************************************************************/ +void FreeBcchDlSchMsg(BCCH_DL_SCH_Message_t bcchMsg) +{ + switch(bcchMsg.message.present) + { + case BCCH_DL_SCH_MessageType_PR_c1: + { + switch(bcchMsg.message.choice.c1->present) + { + case BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1: + { + FreeSib1Msg(bcchMsg.message.choice.c1->choice.systemInformationBlockType1); + break; + } + } + DU_FREE(bcchMsg.message.choice.c1, sizeof(struct BCCH_DL_SCH_MessageType__c1)); + break; + } + } +} + /********************************************************************** End of file **********************************************************************/