#include "du_app_rlc_inf.h"
#include "du_mgr_main.h"
#include "du_utils.h"
+#include "RAT-Type.h"
+#include "FeatureSetUplinkPerCC.h"
+#include "FeatureSetDownlinkPerCC.h"
+#include "FeatureSets.h"
+#include "UE-NR-Capability.h"
+#include "UE-CapabilityRAT-Container.h"
+#include "UE-CapabilityRAT-ContainerListRRC.h"
#include "GNB-DU-System-Information.h"
#include "CellGroupConfigRrc.h"
#include "MAC-CellGroupConfig.h"
#include "DUtoCURRCContainer.h"
#include "GBR-QoSFlowInformation.h"
#include "QoSFlowLevelQoSParameters.h"
+#include "PUCCH-Config.h"
+#include "PUCCH-ResourceSet.h"
+#include "PUCCH-Resource.h"
+#include "PUCCH-PowerControl.h"
+#include "P0-PUCCH.h"
+#include "PUCCH-PathlossReferenceRS.h"
+#include "PUCCH-format0.h"
+#include "PUCCH-format1.h"
+#include "PUCCH-format2.h"
+#include "PUCCH-format3.h"
+#include "PUCCH-format4.h"
+#include "PUCCH-FormatConfig.h"
+#include "SchedulingRequestResourceConfig.h"
#include<ProtocolIE-Field.h>
#include "ProtocolExtensionField.h"
#include "F1AP-PDU.h"
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Builds NRCell ID
+ *
+ * @details
+ *
+ * Function : BuildNrCellId
+ *
+ * Functionality: Building the NR Cell ID
+ *
+ * @params[in] BIT_STRING_t *nrcell
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+S16 BuildNrCellId(BIT_STRING_t *nrcell)
+{
+ memset(nrcell->buf, 0, nrcell->size);
+ nrcell->buf[4] = 16;
+ nrcell->bits_unused = 4;
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Builds Nrcgi
uint8_t BuildNrcgi(NRCGI_t *nrcgi)
{
uint8_t ret;
- uint8_t unused = 4;
uint8_t byteSize = 5;
- uint8_t val = 16;
/* Allocate Buffer Memory */
nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
return RFAILED;
}
/*nrCellIdentity*/
- //ret = BuildNrCellId(&nrcgi->nRCellIdentity);
nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
if(nrcgi->nRCellIdentity.buf == NULLP)
{
return RFAILED;
}
- ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
- if(ret != ROK)
- {
- return RFAILED;
- }
+ BuildNrCellId(&nrcgi->nRCellIdentity);
+
return ROK;
}
/*******************************************************************
memset(lcCfg, 0, sizeof(LcCfg));
}
+/*******************************************************************
+ *
+ * @brief Free UE NR Capability received in UE Context setup request
+ *
+ * @details
+ *
+ * Function : freeUeNrCapability
+ *
+ * Functionality:
+ * Free UE NR Capability received in UE Context setup request
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void freeUeNrCapability(void *ueNrCapability)
+{
+ uint8_t idx;
+ FeatureSets_t *featureSets;
+ UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
+
+ if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
+ {
+ for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
+ {
+ if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
+ free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx]);
+ }
+ free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
+ }
+
+ if(ueNrCap->featureSets)
+ {
+ featureSets = ueNrCap->featureSets;
+ if(featureSets->featureSetsDownlinkPerCC)
+ {
+ if(featureSets->featureSetsDownlinkPerCC->list.array)
+ {
+ for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
+ {
+ if(featureSets->featureSetsDownlinkPerCC->list.array[idx])
+ {
+ if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
+ free(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL);
+ free(featureSets->featureSetsDownlinkPerCC->list.array[idx]);
+ }
+ }
+ free(featureSets->featureSetsDownlinkPerCC->list.array);
+ }
+ free(featureSets->featureSetsDownlinkPerCC);
+ }
+ if(featureSets->featureSetsUplinkPerCC)
+ {
+ if(featureSets->featureSetsUplinkPerCC->list.array)
+ {
+ for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
+ {
+ if(featureSets->featureSetsUplinkPerCC->list.array[idx])
+ {
+ if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
+ free(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL);
+ free(featureSets->featureSetsUplinkPerCC->list.array[idx]);
+ }
+ }
+ free(featureSets->featureSetsUplinkPerCC->list.array);
+ }
+ free(featureSets->featureSetsUplinkPerCC);
+ }
+ free(ueNrCap->featureSets);
+ }
+}
+
/*******************************************************************
*
* @brief Function to free DuUeCfg
{
uint8_t lcIdx;
+ if(ueCfg->ueNrCapability)
+ {
+ freeUeNrCapability(ueCfg->ueNrCapability);
+ DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
+ ueCfg->ueNrCapability = NULLP;
+ }
if(ueCfg->cellGrpCfg)
{
DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
ueCfg->cellGrpCfg = NULLP;
}
- if(ueCfg->maxAggrBitRate)
+ if(ueCfg->ambrCfg)
{
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->maxAggrBitRate, sizeof(MaxAggrBitRate));
+ memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
}
for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
{
}
freeDuUeCfg(&f1UeDb->duUeCfg);
memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
+ DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
}
/*******************************************************************
{
macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
- //macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbol = \
-
- //macPdschCfg->timeDomRsrcAllociList[timeDomIdx].symbolLength;
macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
}
}
}
}
- macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
+ macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
*(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
- timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
+ timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
- //macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbol = \
- timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbol;
- //macPuschCfg->timeDomRsrcAllocList[timeDomIdx].symbolLen = \
- timeDomAllocList->choice.setup->list.array[timeDomIdx]->symbolLen;
}
}
}
}
}
}
+
+/*******************************************************************
+ *
+ * @brief Function to fill pucch Power Control
+ *
+ * @details
+ *
+ * Function : extractPucchPowerControl
+ *
+ * Functionality: Function to fill pucch Power Control
+ *
+ * @params[in] PucchPowerControl *pwrCtrl,
+ * struct PUCCH_PowerControl *cuPwrCtrlCfg
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
+{
+ uint8_t arrIdx;
+
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
+ pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
+ pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
+ pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
+ pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
+ if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
+ pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
+ if(cuPwrCtrlCfg->p0_Set)
+ {
+ pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
+ for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
+ {
+ pwrCtrl->p0Set[arrIdx].p0PucchId =\
+ cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
+ pwrCtrl->p0Set[arrIdx].p0PucchVal =\
+ cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
+ }
+ }
+ if(cuPwrCtrlCfg->pathlossReferenceRSs)
+ {
+ pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
+ for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
+ {
+ pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
+ cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
+ }
+ }
+}
+
+ /*******************************************************************
+ *
+ * @brief Function to extractResrcSetToAddModList sent by CU
+ *
+ * @details
+ *
+ * Function : extractResrcSetToAddModList
+ *
+ * Functionality: Fucntion to extractResrcSetToAddModList
+ *
+ * @params[in] PucchResrcSetCfg pointer,
+ * struct PUCCH_Config__resourceSetToAddModList pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
+{
+ uint8_t arrIdx, rsrcListIdx;
+
+ macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
+ for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
+ {
+ macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId =\
+ cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
+ macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
+ cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
+ for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
+ {
+ macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
+ *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
+ }
+ macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
+ *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
+ }
+}/* End of extractResrcSetToAddModList */
+
+/*******************************************************************
+ *
+ * @brief Fills extractResrcToAddModList sent by CU
+ *
+ * @details
+ *
+ * Function : extractResrcToAddModList
+ *
+ * Functionality: Fills extractResrcToAddModList
+ *
+ * @params[in] PucchResrcCfg pointer,
+ * struct PUCCH_Config__resourceToAddModList pointer
+ * @return ROk/RFAILED
+ *
+ * ****************************************************************/
+
+uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
+{
+ uint8_t arrIdx;
+
+ macResrcList->resrcToAddModListCount = cuResrcList->list.count;
+ for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
+ {
+ macResrcList->resrcToAddModList[arrIdx].resrcId =\
+ cuResrcList->list.array[arrIdx]->pucch_ResourceId;
+ macResrcList->resrcToAddModList[arrIdx].startPrb =\
+ cuResrcList->list.array[arrIdx]->startingPRB;
+ if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
+ {
+ macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
+ *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
+ }
+ if(cuResrcList->list.array[arrIdx]->secondHopPRB)
+ {
+ macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
+ *cuResrcList->list.array[arrIdx]->secondHopPRB;
+ }
+ /* PUCCH RSRC FORMAT */
+ if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format0)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
+ cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
+ }
+ }
+ else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format1)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
+ cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
+ cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
+ }
+ }
+ else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format2)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
+ cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
+ }
+ }
+ else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format3)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
+ cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
+ }
+ }
+ else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
+ {
+ macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
+ if(cuResrcList->list.array[arrIdx]->format.choice.format4)
+ {
+ DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
+ if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
+ return RFAILED;
+ }
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
+ cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
+ cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
+ macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
+ cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
+ }
+ }
+ }
+ return ROK;
+
+}/* End of extractResrcToAddModList */
+
+/*******************************************************************
+ *
+ * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
+ *
+ * @details
+ *
+ * Function : fillPucchSchedReqPeriodAndOffset
+ *
+ * Functionality: To fillPucchSchedReqPeriodAndOffset
+ *
+ * @params[in] macPeriodicty,
+ * SchedulingRequestResourceConfig__periodicityAndOffset pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t macOffset,\
+ struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
+{
+ macPeriodicty = cuPeriodicty->present;
+ switch(macPeriodicty)
+ {
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
+ {
+ macOffset = cuPeriodicty->choice.sym2;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
+ {
+ macOffset = cuPeriodicty->choice.sym6or7;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
+ {
+ macOffset = cuPeriodicty->choice.sl1;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
+ {
+ macOffset = cuPeriodicty->choice.sl2;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
+ {
+ macOffset = cuPeriodicty->choice.sl4;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
+ {
+ macOffset = cuPeriodicty->choice.sl5;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
+ {
+ macOffset = cuPeriodicty->choice.sl8;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
+ {
+ macOffset = cuPeriodicty->choice.sl10;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
+ {
+ macOffset = cuPeriodicty->choice.sl16;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
+ {
+ macOffset = cuPeriodicty->choice.sl20;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
+ {
+ macOffset = cuPeriodicty->choice.sl40;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
+ {
+ macOffset = cuPeriodicty->choice.sl80;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
+ {
+ macOffset = cuPeriodicty->choice.sl160;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
+ {
+ macOffset = cuPeriodicty->choice.sl320;
+ break;
+ }
+ case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
+ {
+ macOffset = cuPeriodicty->choice.sl640;
+ break;
+ }
+ default :
+ DU_LOG("\nERROR --> F1AP : Invalid periodicity %d", macPeriodicty);
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Function to extractPucchFormatCfg sent by CU
+ *
+ * @details
+ *
+ * Function : extractPucchFormatCfg
+ *
+ * Functionality: Function to extractPucchFormatCfg
+ *
+ * @params[in] PucchFormatCfg pointer,
+ * PUCCH_FormatConfig_t pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
+ {
+ if(cuFormatCfg->interslotFrequencyHopping)
+ macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
+ if(cuFormatCfg->additionalDMRS)
+ macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
+ if(cuFormatCfg->maxCodeRate)
+ macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
+ if(cuFormatCfg->nrofSlots)
+ macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
+ if(cuFormatCfg->pi2BPSK)
+ macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
+ if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
+ macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
+ }/* End of extractPucchFormatCfg */
+
+/*******************************************************************
+ *
+ * @brief Function to extractSchedReqCfgToAddMod sent by CU
+ *
+ * @details
+ *
+ * Function : extractSchedReqCfgToAddMod
+ *
+ * Functionality: Function to extractSchedReqCfgToAddMod
+ *
+ * @params[in] PucchSchedReqCfg pointer,
+ * PUCCH_Config__schedulingRequestResourceToAddModList pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
+{
+ uint8_t arrIdx;
+
+ macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
+ for(arrIdx = 0; arrIdx < macSchedReqCfg->schedAddModListCount; arrIdx++)
+ {
+ macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
+ cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
+ macSchedReqCfg->schedAddModList[arrIdx].requestId =\
+ cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
+ if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
+ {
+ fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
+ macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
+ }
+ if(cuSchedReqList->list.array[arrIdx]->resource)
+ {
+ macSchedReqCfg->schedAddModList[arrIdx].resrc =\
+ *cuSchedReqList->list.array[arrIdx]->resource;
+ }
+ }
+
+}/* End of extractSchedReqCfgToAddMod */
+
+ /*******************************************************************
+ *
+ * @brief Fills PucchCfg received by CU
+ *
+ * @details
+ *
+ * Function : extractPucchCfg
+ *
+ * Functionality: Fills PucchCfg received by CU
+ *
+ * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
+ * PucchCfg *macPucchCfg
+ * @return ROK/RFAILED
+ *
+ * ****************************************************************/
+
+uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
+{
+ uint8_t arrIdx;
+
+ if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
+ {
+ if(cuPucchCfg->choice.setup)
+ {
+ /* Resource Set Cfg */
+ if(cuPucchCfg->choice.setup->resourceSetToAddModList)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
+ if(macPucchCfg->resrcSet == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
+ extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
+ }
+
+ /* Resource Cfg */
+ if(cuPucchCfg->choice.setup->resourceToAddModList)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
+ if(macPucchCfg->resrc == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
+ extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
+ }
+
+ /* Format 1 Cfg */
+ if(cuPucchCfg->choice.setup->format1)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
+ if(macPucchCfg->format1 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
+ extractPucchFormatCfg(macPucchCfg->format1,\
+ cuPucchCfg->choice.setup->format1->choice.setup);
+ }
+
+ /* Format 2 Cfg */
+ if(cuPucchCfg->choice.setup->format2)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
+ if(macPucchCfg->format2 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
+ extractPucchFormatCfg(macPucchCfg->format2,\
+ cuPucchCfg->choice.setup->format2->choice.setup);
+ }
+
+ /* Format 3 Cfg */
+ if(cuPucchCfg->choice.setup->format3)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
+ if(macPucchCfg->format3 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
+ extractPucchFormatCfg(macPucchCfg->format3,\
+ cuPucchCfg->choice.setup->format3->choice.setup);
+ }
+
+ /* Format 4 Cfg */
+ if(cuPucchCfg->choice.setup->format4)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
+ if(macPucchCfg->format4 == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
+ extractPucchFormatCfg(macPucchCfg->format4,\
+ cuPucchCfg->choice.setup->format4->choice.setup);
+ }
+
+ /* Sched Req List */
+ if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
+ if(macPucchCfg->schedReq == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
+ extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
+ cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
+ }
+
+ /*TODO: Add support for Spatial Info */
+
+ /* MultiCsiCfg */
+ if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
+ if(macPucchCfg->multiCsiCfg == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
+ macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
+ for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
+ {
+ macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
+ *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
+ }
+ }
+
+ /* Dl_DataToUL_ACK */
+ if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
+ if(macPucchCfg->dlDataToUlAck == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
+ return RFAILED;
+ }
+ memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
+ macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
+ for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
+ {
+ macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
+ *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
+ }
+ }
+
+ /* Power Control */
+ if(cuPucchCfg->choice.setup->pucch_PowerControl)
+ {
+ DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
+ if(macPucchCfg->powerControl == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
+ return RFAILED;
+ }
+ extractPucchPowerControl(macPucchCfg->powerControl,\
+ cuPucchCfg->choice.setup->pucch_PowerControl);
+ }
+ }
+ }
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Fills ServingCellReconfig received by CU
*
* @details
*
- * Function : extractServingCellReconfig
+ * Function : extractSpCellDedicatedCfg
*
* Functionality: Fills ServingCellReconfig received by CU
*
* @return ROK/RFAILD
*
* ****************************************************************/
-uint8_t extractServingCellReconfig(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
+uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
{
uint8_t ret = ROK;
BWP_DownlinkDedicated_t *dlBwp = NULLP;
{
if(dlBwp->pdcch_Config->choice.setup)
{
+ macSrvCellCfg->initDlBwp.pdcchPresent = true;
extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
}
}
{
if(dlBwp->pdsch_Config->choice.setup)
{
+ macSrvCellCfg->initDlBwp.pdschPresent = true;
extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
}
}
}
else
{
- DU_LOG("\nMemory Alloc failed for bwpInactivityTmr at extractServingCellReconfig()");
+ DU_LOG("\nERROR --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
return RFAILED;
}
}
ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
if(ret == RFAILED)
{
- DU_LOG("\nFailed at extractPdschServingCellCfg()");
+ DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
return RFAILED;
}
}
if(ulBwp->pucch_Config)
{
macSrvCellCfg->initUlBwp.pucchPresent = true;
- //extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
+ memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
+ extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
}
}
if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
-
}
return ret;
}
macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
}
}
-
-
}
}
/* Fill Physical Cell Group Reconfig */
if(cellGrp->spCellConfig->spCellConfigDedicated)
{
servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
- ret = extractServingCellReconfig(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
+ ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
if(ret == RFAILED)
{
- DU_LOG("\n Failed at extractServingCellReconfig()");
+ DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
}
}
}
return ret;
}
+/*******************************************************************
+ *
+ * @brief Filling modulation info in mac ue cfg
+ *
+ * @details
+ *
+ * Function : duFillModulationDetails
+ *
+ * Functionality: Filling modulation info in mac ue cfg
+ *
+ * @params[in] MAC UE Config to be updated
+ * Current UE configuration
+ * UE NR capability from CU
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
+{
+ UE_NR_Capability_t *ueNrCap;
+
+ if(ueCap)
+ ueNrCap = (UE_NR_Capability_t *)ueCap;
+
+ /* Filling DL modulation info */
+ if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
+ ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
+ ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
+ {
+ switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
+ {
+ case ModulationOrder_qpsk:
+ {
+ ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
+ break;
+ }
+ case ModulationOrder_qam16:
+ {
+ ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
+ break;
+ }
+ case ModulationOrder_qam64:
+ {
+ ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
+ ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
+ ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
+ break;
+ }
+ case ModulationOrder_qam256:
+ {
+ ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nDU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
+ memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
+ break;
+ }
+ }
+ }
+ else
+ {
+ memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
+ }
+
+ /* Filling UL modulation info */
+ if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
+ ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
+ ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
+ {
+ switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
+ {
+ case ModulationOrder_qpsk:
+ {
+ ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
+ break;
+ }
+ case ModulationOrder_qam16:
+ {
+ ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
+ ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
+ ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
+ break;
+ }
+ case ModulationOrder_qam64:
+ {
+ ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
+ break;
+ }
+ case ModulationOrder_qam256:
+ {
+ ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nDU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
+ memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
+ break;
+ }
+ }
+ }
+ else
+ {
+ memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
+ }
+}
+
/*******************************************************************
*
* @brief Function to extract cellGrp Info present in cutoDu cont
return ret;
}
+/*******************************************************************
+ *
+ * @brief Extract UE capability info
+ *
+ * @details
+ *
+ * Function : extractUeCapability
+ *
+ * Functionality: Extract UE capability info and stores in ue Cb
+ *
+ * @params[in] Octet string of UE capability RAT container list
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
+{
+ uint8_t idx;
+ uint16_t recvBufLen;
+ asn_dec_rval_t rval;
+ UE_NR_Capability_t *ueNrCap = NULLP;
+ UE_CapabilityRAT_ContainerListRRC_t *ueCapRatContList = NULLP;
+
+ /* Decoding UE Capability RAT Container List */
+ recvBufLen = ueCapablityListBuf->size;
+ DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
+ if(!ueCapRatContList)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in extractUeCapability");
+ return NULLP;
+ }
+ memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
+ memset(&rval, 0, sizeof(asn_dec_rval_t));
+ rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
+ ueCapablityListBuf->buf, recvBufLen, 0, 0);
+ if(rval.code == RC_FAIL || rval.code == RC_WMORE)
+ {
+ DU_LOG("\nF1AP : ASN decode failed at decodeCellGrpCfg()");
+ return NULLP;
+ }
+ xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
+
+ /* Free encoded buffer after decoding */
+ free(ueCapablityListBuf->buf);
+
+ for(idx = 0; idx < ueCapRatContList->list.count; idx++)
+ {
+ if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
+ {
+ /* Decoding UE NR Capability */
+ recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
+ DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
+ if(!ueNrCap)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in extractUeCapability");
+ DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
+ return NULLP;
+ }
+ memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
+ memset(&rval, 0, sizeof(asn_dec_rval_t));
+ rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
+ ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
+ if(rval.code == RC_FAIL || rval.code == RC_WMORE)
+ {
+ DU_LOG("\nF1AP : ASN decode failed at decodeCellGrpCfg()");
+ return NULLP;
+ }
+ xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
+
+ /* Free encoded buffer after decoding */
+ free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
+ }
+ free(ueCapRatContList->list.array[idx]);
+ }
+
+ /* Free Memory*/
+ free(ueCapRatContList->list.array);
+ DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
+ return ueNrCap;
+}
+
/*******************************************************************
*
* @brief Process UE context setup request from CU
{
uint8_t ret, ieIdx, ueIdx, lcId, cellIdx;
bool ueCbFound = false;
- uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
+ uint32_t gnbCuUeF1apId, gnbDuUeF1apId, bitRateSize;
DuUeCb *duUeCb = NULLP;
UEContextSetupRequest_t *ueSetReq = NULLP;
break;
case ProtocolIE_ID_id_CUtoDURRCInformation:
{
+ if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
+ {
+ duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
+ extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
+ uE_CapabilityRAT_ContainerList, duUeCb);
+ }
if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
{
duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
}
case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
{
- duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
+ if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
+ {
+ duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
+ }
+ else
+ {
+ DU_LOG("\nIgnoring delivery report, since rrcContainer is not present");
+ }
break;
}
- //TODO: To handle maxAggrBitRate case,
- // Dependency: The protocolIE is not specified in ASN
-#if 0
- case ProtocolIE_ID_id_ULPDUSessionAggregateMaximumBitRate: {
+ case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
+ {
/* MaximumBitRate Uplink */
bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
if(bitRateSize > 0)
{
- DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.maxAggrBitRate, bitRateSize);
- if(!duUeCb->f1UeDb->duUeCfg.maxAggrBitRate)
+ DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
+ if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
{
DU_LOG("\nDU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
ret = RFAILED;
}
else
{
- duUeCb->f1UeDb->duUeCfg.maxAggrBitRate->ulBits =\
- *ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf;
- duUeCb->f1UeDb->duUeCfg.maxAggrBitRate->dlBits = 0;
+ memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
+ memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
+ ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
+ duUeCb->f1UeDb->duUeCfg.ambrCfg->dlBr = 0;
}
}
else
ret = RFAILED;
break;
}
-#endif
default:
{
break;
choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
/* Free UeContext Db created during Ue context Req */
freeF1UeDb(ueCb->f1UeDb);
+ ueCb->f1UeDb = NULLP;
}
}
else
cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
- if(nci <= 0 || nci > MAX_NUM_CELL)
- {
- DU_LOG("\nDU APP : Invalid NCI %d", nci);
- return RFAILED;
- }
if(cell.nRPCI)
{
pci = *cell.nRPCI;
}
- ret = duProcCellsToBeActivated(nci, pci);
+ ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
}
return ret;
}
Code Review / o-du / l2.git / blobdiff