}
/*******************************************************************
- * @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
* 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;
}
}
/*******************************************************************
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
{
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);
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;
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 */
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 */
#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;
#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;
#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; freqBandIdx<MAX_NRCELL_BANDS; freqBandIdx++)
{
#ifdef O1_ENABLE
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn = cellParams.arfcnUL;
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.sulInfo.sulArfcn = cellParams.arfcnSUL;
- duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulTxBw.nrScs = convertScsPeriodicityToEnum(cellParams.ssbPeriodicity);
- duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.sulInfo.sulTxBw.nrScs = convertScsPeriodicityToEnum(cellParams.ssbPeriodicity);
+ duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulTxBw.nrScs = cellParams.ssbSubCarrierSpacing;
+ duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.sulInfo.sulTxBw.nrScs = cellParams.ssbSubCarrierSpacing;
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.nrArfcn = cellParams.arfcnDL;
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.sulInfo.sulArfcn = cellParams.arfcnSUL;
- duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.sulInfo.sulTxBw.nrScs = convertScsPeriodicityToEnum(cellParams.ssbPeriodicity);
- duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlTxBw.nrScs = convertScsPeriodicityToEnum(cellParams.ssbPeriodicity);
+ duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.sulInfo.sulTxBw.nrScs = cellParams.ssbSubCarrierSpacing;
+ duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlTxBw.nrScs = cellParams.ssbSubCarrierSpacing;
#else
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn = NR_UL_ARFCN;
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.sulInfo.sulArfcn = SUL_ARFCN;
- duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulTxBw.nrScs = SSB_PRDCTY_MS_20;
- duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.sulInfo.sulTxBw.nrScs = SSB_PRDCTY_MS_20;
+ duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulTxBw.nrScs = NR_SCS;
+ duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.sulInfo.sulTxBw.nrScs = NR_SCS;
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.nrArfcn = NR_DL_ARFCN;
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.sulInfo.sulArfcn = SUL_ARFCN;
- duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.sulInfo.sulTxBw.nrScs = SSB_PRDCTY_MS_20;
- duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlTxBw.nrScs = SSB_PRDCTY_MS_20;
+ duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.sulInfo.sulTxBw.nrScs = NR_SCS;
+ duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.dlTxBw.nrScs = NR_SCS;
#endif
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.sulInfo.sulTxBw.nrb = NRB_106;
for(freqBandIdx=0; freqBandIdx<MAX_NRCELL_BANDS; freqBandIdx++)
#endif
/*Measurement Config and Cell Config */
- duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.measTimeCfg = TIME_CFG;
+ duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.measTimeCfgDuration = TIME_CFG;
duCfgParam.srvdCellLst[srvdCellIdx].duCellInfo.cellDir = DL_UL;
#define SUL_ARFCN 100
#define SUL_BAND 2
-#define TIME_CFG 0
+#define TIME_CFG 4
+#define MEAS_TIMING_ARFCN 630432
#define CARRIER_IDX 1
#define NUM_TX_ANT 2
#define NUM_RX_ANT 2
uint16_t tac; /* tracking area code */
uint16_t epsTac; /* Configured EPS TAC */
NrModeInfo f1Mode; /* NR mode info : FDD/TDD */
- uint8_t measTimeCfg; /* Measurement timing configuration */
+ uint8_t measTimeCfgDuration; /* Measurement timing configuration */
F1CellDir cellDir; /* Cell Direction */
F1CellType cellType; /* Cell Type */
F1BrdcstPlmnInfo brdcstPlmnInfo[MAX_BPLMN_NRCELL_MINUS_1]; /* Broadcast PLMN Identity Info List */
long cellResvdForOpUse;
long connEstFailCnt;
long connEstFailOffValidity;
+ long connEstFailOffset;
SiSchedInfo siSchedInfo;
SrvCellCfgCommSib srvCellCfgCommSib;
}Sib1Params;
F1EgtpParams egtpParams; /* EGTP Params */
uint32_t maxUe;
uint32_t duId;
- uint8_t duName[CU_DU_NAME_LEN_MAX];
+ char *duName;
SchedulerCfg schedCfg;
F1DuSrvdCellInfo srvdCellLst[MAX_NUM_CELL]; /* Serving cell list *///TODO: this must be removed eventually
F1RrcVersion rrcVersion; /* RRC version */
#include "ReconfigurationWithSync.h"
#include "du_sys_info_hdl.h"
#include "DRX-ConfigRrc.h"
+#include "MeasurementTimingConfigurationRrc.h"
+#include "MeasurementTimingConfigurationRrc-IEs.h"
+#include "MeasTimingList.h"
+#include "MeasTiming.h"
#ifdef O1_ENABLE
#include "CmInterface.h"
freqInfo->freqBandListNr.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*);
}
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
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,
{
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
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 );
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
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++;
break;
}
-
/*RRC Version*/
ieIdx++;
f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
#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;
}
#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"
DU_LOG("\nERROR --> DU APP: BuildPlmnList memory allocation failure");
return RFAILED;
}
+
elementCnt = cellAccessInfo->plmn_IdentityList.list.count;
for(idx=0; idx<elementCnt; idx++)
{
/* PLMN list */
elementCnt = ODU_VALUE_ONE;
- plmnIdInfo = &cellAccessInfo->plmn_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);
for(idx1=0; idx1<elementCnt; idx1++)
{
- DU_ALLOC(plmnIdInfo->list.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");
}
}
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");
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; idx2<elementCnt; idx2++)
{
DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc->list.array[idx2],
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)
return RFAILED;
}
}
+#endif
+
return ROK;
}/* BuildCommonSerachSpaceList */
* ****************************************************************/
uint8_t BuildSib1Msg()
{
+ BCCH_DL_SCH_Message_t bcchMsg;
SIB1_t *sib1Msg;
CellAccessRelatedInfo_t *cellAccessInfo;
uint8_t elementCnt;
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;
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));
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");
break;
}while(true);
- FreeSib1Msg(sib1Msg);
+ FreeBcchDlSchMsg(bcchMsg);
return ret;
-
-
}
+
/*******************************************************************
*
* @brief : deallocating the memory of BuildSib1Msg
}
+/*******************************************************************
+ *
+ * @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
**********************************************************************/
Code Review / o-du / l2.git / commitdiff