strcpy(message,"EVENT_MAC_SLICE_CFG_REQ");
break;
case EVENT_MAC_SLICE_RECFG_REQ:
- strcpy(message,"EVENT_MAC_SLICE_CFG_REQ");
+ strcpy(message,"EVENT_MAC_SLICE_RECFG_REQ");
break;
default:
strcpy(message,"Invalid Event");
return RFAILED;
}
- memcpy(storeSliceCfg->listOfConfirguration[sliceIdx], cfgReq->listOfConfirguration[sliceIdx], sizeof(SchRrmPolicyOfSlice));
+ memcpy(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &cfgReq->listOfConfirguration[sliceIdx]->snssai, sizeof(Snssai));
+ memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, cfgReq->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo,
+ sizeof(SchRrmPolicyRatio));
sliceIdx++;
}
}
{
if(!memcmp(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &cfgReq->listOfConfirguration[cfgIdx]->snssai, sizeof(Snssai)))
{
- storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo = cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo;
+ memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo,
+ sizeof(SchRrmPolicyRatio));
break;
}
}
*
* @details
*
- * Function : packDuMacSliceReCfgRsp
+ * Function : packMacSlotInd
*
* Functionality:
* Pack and send Slot ind from MAC to DU APP
#define BSR_RETX_TIMER_SF_320 320
#define BSR_SR_DELAY_TMR_2560 2560
-#define GET_PAGING_CYCLE(enmValue, T) { \
- if (enmValue == 0) T = 32; \
- else if (enmValue == 1) T = 64; \
- else if (enmValue == 2) T = 128; \
- else if (enmValue == 3) T = 256; \
- else T = 0; \
-}
-
-#define GET_NUM_PAGING_OCC(enmValue, PO) { \
- if (enmValue == 0) PO = 4; \
- else if (enmValue == 1) PO = 2; \
- else if (enmValue == 2) PO = 1; \
- else PO = 0; \
-}
-
#define PAGING_SCHED_DELTA 4
typedef enum
*
* ****************************************************************/
-uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint8_t val)
+uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint64_t data)
{
- uint8_t tmp;
+ uint64_t tmp = 0;
+ uint8_t byteIdx = 0;
+
if(id->buf == NULLP)
{
+ DU_LOG("\nERROR --> DU_APP : Buffer allocation is empty");
return RFAILED;
}
-
- memset(id->buf, 0, byteSize-1);
- id->buf[byteSize-1] = val;
+ memset(id->buf, 0, byteSize);
+ data = data << unusedBits;
+
+ /*Now, seggregate the value into 'byteSize' number of Octets in sequence:
+ * 1. Pull out a byte of value (Starting from MSB) and put in the 0th Octet
+ * 2. Fill the buffer/String Octet one by one until LSB is reached*/
+ for(byteIdx = 1; byteIdx <= byteSize; byteIdx++)
+ {
+ tmp = (uint64_t)0xFF;
+ tmp = (tmp << (8 * (byteSize - byteIdx)));
+ tmp = (data & tmp) >> (8 * (byteSize - byteIdx));
+ id->buf[byteIdx - 1] = tmp;
+ }
id->bits_unused = unusedBits;
return ROK;
}
uint8_t bitStringToInt(BIT_STRING_t *bitString, void *value)
{
uint16_t idx;
- uint32_t *val = NULLP;
+ uint64_t *val = NULLP;
if(bitString->buf == NULL || bitString->size <= 0)
{
- DU_LOG("\nDU_APP : Bit string is empty");
+ DU_LOG("\nERROR --> DU_APP : Bit string is empty");
return RFAILED;
}
if(value)
- val = (uint32_t *)value;
+ val = (uint64_t *)value;
else
return RFAILED;
int encBufSize;
int PrepFinalEncBuf(const void *buffer, size_t size, void *encodedBuf);
-uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint8_t val);
+uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint64_t val);
uint8_t bitStringToInt(BIT_STRING_t *bitString, void *val);
void fillTeIdString(uint8_t bufSize, uint32_t val, uint8_t *buf);
void teIdStringToInt(uint8_t *buf, uint32_t *val);
#include "MeasConfigRrc.h"
#include "AS-Config.h"
#include "RRCReconfiguration-v1530-IEs.h"
+#include "CNUEPagingIdentity.h"
+#include "PagingCell-Item.h"
#include "cu_stub_sctp.h"
#include "cu_stub_egtp.h"
uint8_t ret;
uint8_t unused_bits = 4;
uint8_t byteSize = 5;
- uint8_t val = nrCellId << unused_bits;
/* Allocate Buffer Memory */
nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
{
return RFAILED;
}
- fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, val);
+ fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildULTnlInfo(TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
+uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
{
uint8_t idx;
uint8_t ulCnt;
ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
- ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
+ ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.egtpAssoc[duId-1].currTunnelId++;
ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildDRBSetup(CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
+uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
{
uint8_t idx = 0, extIeIdx = 0;
uint8_t elementCnt = 0, drbCnt = 0;
/*ULUPTNLInformation To Be Setup List*/
if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
- BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
+ BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
FALSE);
else
- BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
+ BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
TRUE);
if(BuildULTnlInforet != ROK)
{
* @return void
*
* ****************************************************************/
-uint8_t freeQuantityConfig(QuantityConfig_t *quantityCfg)
+void freeQuantityConfig(QuantityConfig_t *quantityCfg)
{
uint8_t quanCfgIdx;
QuantityConfigNR_t *quantityCfgNr;
ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
- ret1 = BuildDRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
+ ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
if(ret1 != ROK)
{
break;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t addDrbTunnels(uint8_t teId)
+uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
{
uint8_t ret = ROK;
EgtpTnlEvt tnlEvt;
tnlEvt.action = EGTP_TNL_MGMT_ADD;
tnlEvt.lclTeid = teId;
tnlEvt.remTeid = teId;
- ret = cuEgtpTnlMgmtReq(tnlEvt);
+ ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
if(ret != ROK)
{
DU_LOG("\nERROR --> EGTP : Tunnel management request failed for teId %x", teId);
* RFAILED - failure
*
* ****************************************************************/
-uint8_t procDrbSetupList(DRBs_Setup_List_t *drbSetupList)
+uint8_t procDrbSetupList(uint32_t duId, DRBs_Setup_List_t *drbSetupList)
{
uint8_t arrIdx = 0;
uint32_t teId = 0;
teId = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
if(teId > 0)
{
- if(addDrbTunnels(teId)== ROK)
+ if(addDrbTunnels(duId, teId)== ROK)
{
DU_LOG("\nDEBUG --> EGTP: Tunnel Added for TeId %d", teId);
}
case ProtocolIE_ID_id_DRBs_Setup_List:
{
/* Adding Tunnels for successful DRB */
- procDrbSetupList(&ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
+ procDrbSetupList(duId, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
break;
}
case ProtocolIE_ID_id_DUtoCURRCInformation:
* RFAILED - failure
*
* ****************************************************************/
-uint8_t deleteEgtpTunnel(uint8_t *buf)
+uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
{
uint32_t teId = 0;
EgtpTnlEvt tnlEvt;
tnlEvt.action = EGTP_TNL_MGMT_DEL;
tnlEvt.lclTeid = teId;
tnlEvt.remTeid = teId;
- if((cuEgtpTnlMgmtReq(tnlEvt)) != ROK)
+ if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
{
DU_LOG("\nERROR --> EGTP : Failed to delete tunnel Id %d", teId);
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildUlTnlInfoforSetupMod(uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
+uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
{
uint8_t arrIdx;
uint8_t ulCnt;
else
{
ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
- gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
+ gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.egtpAssoc[duId-1].currTunnelId++;
}
ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
*
* ****************************************************************/
-uint8_t FillDrbItemToSetupMod(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
+uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
{
uint8_t ret = ROK;
}
/*ULUPTNLInformation To Be Setup List*/
- ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
+ ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
&drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
if(ret != ROK)
{
*
* ****************************************************************/
-uint8_t FillDrbItemList(CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
+uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
{
drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
drbItemIe->criticality = Criticality_reject;
drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
- if(FillDrbItemToSetupMod(ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
+ if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbItemToSetupMod failed");
return RFAILED;
*
* ****************************************************************/
-uint8_t BuildDrbToBeSetupList(CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
+uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
{
uint8_t ret = ROK;
uint8_t arrIdx =0;
return RFAILED;
}
- ret = FillDrbItemList(ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
+ ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbItemList failed");
*
* ****************************************************************/
-uint8_t FillDrbToBeModItem(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
+uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
{
uint8_t ret = ROK;
uint drbIdx=0;
}/* End of QoS */
/*ULUPTNLInformation To Be Setup List*/
- ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
+ ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
ProtocolIE_ID_id_DRBs_ToBeModified_Item);
if(ret != ROK)
{
*
* ****************************************************************/
-uint8_t FillDrbToBeModItemList(CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
+uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
{
drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
drbItemIe->criticality = Criticality_reject;
drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
- if(FillDrbToBeModItem(ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
+ if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbToBeModItem failed");
return RFAILED;
*
* ****************************************************************/
-uint8_t BuildDrbToBeModifiedList(CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
+uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
{
uint8_t ret = ROK;
uint8_t arrIdx =0;
return RFAILED;
}
- ret = FillDrbToBeModItemList(ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
+ ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbToBeModItemList failed");
ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
- ret = BuildDrbToBeSetupList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
+ ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
value.choice.DRBs_ToBeSetupMod_List));
/* DRB to be modified list */
ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
- ret = BuildDrbToBeModifiedList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
+ ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
value.choice.DRBs_ToBeModified_List));
/* TODO: DRB to be release list */
* RFAILED - failure
*
* ****************************************************************/
-uint8_t procDrbSetupModList(CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
+uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
{
uint8_t arrIdx = 0, drbIdx;
uint32_t teId = 0;
teId = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
if(teId > 0)
{
- if(addDrbTunnels(teId)== ROK)
+ if(addDrbTunnels(duId, teId)== ROK)
{
DU_LOG("\nDEBUG --> EGTP: Tunnel Added for TeId %d", teId);
}
case ProtocolIE_ID_id_DRBs_SetupMod_List:
{
/* Adding Tunnels for successful DRB */
- procDrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
+ procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
break;
}
}
}
+/*******************************************************************
+ *
+ * @brief Builds the Paging cell list
+ *
+ * @details
+ *
+ * Function : BuildPagingCellList
+ *
+ * Functionality: Build the paging cell list
+ *
+ * @params[in] PagingCell_list_t *pagingCelllist,
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
+{
+ uint8_t cellIdx =0;
+ PagingCell_ItemIEs_t *pagingCellItemIes;
+ PagingCell_Item_t *pagingCellItem;
+
+ pagingCelllist->list.count = numCells;
+ pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
+ CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
+ if(pagingCelllist->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildPagingCellList(): Memory allocation failed ");
+ return RFAILED;
+ }
+
+ for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
+ {
+ CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
+ if(pagingCelllist->list.array[cellIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildPagingCellList(): Memory allocation failed ");
+ return RFAILED;
+ }
+ }
+
+ for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
+ {
+ pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
+ pagingCellItemIes->id = ProtocolIE_ID_id_PagingCell_Item;
+ pagingCellItemIes->criticality = Criticality_ignore;
+ pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
+ pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
+
+ /* Fill NrCgi Information */
+ BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Deallocation of memory allocated in paging msg
+ *
+ * @details
+ *
+ * Function :FreePagingMsg
+ *
+ * Functionality: Deallocation of memory allocated in paging msg
+ *
+ * @params[in] F1AP_PDU_t *f1apMsg
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void FreePagingMsg(F1AP_PDU_t *f1apMsg)
+{
+ uint8_t ieIdx, cellIdx;
+ Paging_t *paging;
+ PagingCell_ItemIEs_t *pagingCellItemIes;
+ PagingCell_Item_t *pagingCellItem;
+ PagingCell_list_t *pagingCelllist;
+
+ if(f1apMsg)
+ {
+ if(f1apMsg->choice.initiatingMessage)
+ {
+ paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
+ if(paging->protocolIEs.list.array)
+ {
+ for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
+ {
+ if(paging->protocolIEs.list.array[ieIdx])
+ {
+ switch(paging->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_UEIdentityIndexValue:
+ {
+ CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
+ paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
+ break;
+ }
+
+ case ProtocolIE_ID_id_PagingIdentity:
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
+ {
+ CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
+ }
+ CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
+ sizeof(struct CNUEPagingIdentity));
+ }
+ }
+ break;
+ }
+
+ case ProtocolIE_ID_id_PagingCell_List:
+ {
+ pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
+ if(pagingCelllist->list.array)
+ {
+ for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
+ {
+ if(pagingCelllist->list.array[cellIdx])
+ {
+ pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
+ if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
+ {
+ pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
+ CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
+ CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
+ }
+ CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
+ }
+ }
+ CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
+ }
+ break;
+ }
+ }
+ CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
+ }
+ }
+ CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
+ }
+ CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
+ }
+ CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
+ }
+}
+/*******************************************************************
+ *
+ * @brief Builds and sends the paging message if UE is in idle mode
+ *
+ * @details
+ *
+ * Function : BuildAndSendPagingMsg
+ *
+ * Functionality: Builds and sends the paging message
+ *
+ * @params[in] uint32_t duId, uint8_t gsTmsi
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
+{
+ bool memAllocFailed = false;
+ uint8_t ieIdx = 0, elementCnt = 0, ret = RFAILED;
+ uint16_t ueId = 0, duIdx = 0;
+
+ /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
+ *5G-S-TMSI :48 Bits >> 6 Bytes and 0 UnusedBits */
+ uint8_t totalByteInUeId = 2, totalByteInTmsi = 6;
+ uint8_t unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
+
+ F1AP_PDU_t *f1apMsg = NULLP;
+ Paging_t *paging = NULLP;
+ DuDb *duDb;
+ asn_enc_rval_t encRetVal;
+
+ DU_LOG("\nINFO --> F1AP : Building PAGING Message command\n");
+
+ SEARCH_DU_DB(duIdx, duId, duDb);
+ if(duDb == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): DuDb is empty");
+ return ret;
+ }
+
+ while(true)
+ {
+ CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
+ if(f1apMsg == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
+ break;
+ }
+
+ f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
+
+ CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
+ if(f1apMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
+ break;
+ }
+ f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
+ f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
+ f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
+
+ paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
+
+ elementCnt = 5;
+ paging->protocolIEs.list.count = elementCnt;
+ paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
+
+ /* Initialize the Paging Message members */
+ CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
+ if(paging->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg():Memory allocation failed");
+ break;
+ }
+
+ for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
+ {
+ CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
+ if(paging->protocolIEs.list.array[ieIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ memAllocFailed = true;
+ break;
+ }
+ }
+
+ if(memAllocFailed == true)
+ {
+ break;
+ }
+
+ /* UE Identity Index Value */
+ ieIdx=0;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
+ CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
+ paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ break;
+ }
+
+ /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
+ ueId = gsTmsi % 1024;
+ fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
+
+ /* Paging Identity */
+ ieIdx++;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
+ PagingIdentity_PR_cNUEPagingIdentity;
+ CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
+ sizeof(struct CNUEPagingIdentity));
+ if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ break;
+ }
+
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
+ CNUEPagingIdentity_PR_fiveG_S_TMSI;
+
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
+ CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
+ if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
+ break;
+ }
+
+ fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
+ unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
+
+ /* Paging Drx */
+ ieIdx++;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
+
+ /* Paging Priority */
+ ieIdx++;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
+ paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
+
+ /* Paging Cell List */
+ ieIdx++;
+ paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
+ paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
+ paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
+ if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
+ break;
+ }
+
+ xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
+
+ /* Encode the UE Context Release Command type as APER */
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
+ encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> F1AP : Could not encode Release Command structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Paging\n");
+ for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
+ {
+ DU_LOG("%x",encBuf[ieIdx]);
+ }
+ }
+
+ if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Sending Ue context Release Command failed");
+ break;
+ }
+
+ ret = ROK;
+ break;
+
+ }
+
+ FreePagingMsg(f1apMsg);
+ return ret;
+}
+
/*******************************************************************
*
* @brief Handles received F1AP message and sends back response
uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *ueCb, UeCtxtModAction action);
uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId);
uint8_t BuildAndSendF1ResetReq();
+uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId);
/**********************************************************************
End of file
void readCuCfg()
{
- uint8_t *numDu;
+ uint8_t numDu;
uint32_t ipv4_du, ipv4_cu;
DU_LOG("\nDEBUG --> CU_STUB : Reading CU configurations");
cuCb.cuCfgParams.sctpParams.numDu = 1;
#else
cuCb.cuCfgParams.sctpParams.numDu = 0;
- numDu = &cuCb.cuCfgParams.sctpParams.numDu;
- while(*numDu < MAX_DU_SUPPORTED)
+ cuCb.cuCfgParams.egtpParams.numDu = 0;
+ numDu = 0;
+ while(numDu < MAX_DU_SUPPORTED)
{
/* DU IP Address and Port*/
memset(&ipv4_du, 0, sizeof(uint32_t));
- cmInetAddr((S8*)DU_IP_V4_ADDR[*numDu], &ipv4_du);
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].duIpAddr.ipV4Addr = ipv4_du;
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].duIpAddr.ipV6Pres = false;
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].duPort = DU_SCTP_PORT[*numDu];
+ cmInetAddr((S8*)DU_IP_V4_ADDR[numDu], &ipv4_du);
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].duIpAddr.ipV4Addr = ipv4_du;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].duIpAddr.ipV6Pres = false;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].duPort = DU_SCTP_PORT[numDu];
/* CU IP Address and Port*/
memset(&ipv4_du, 0, sizeof(uint32_t));
cmInetAddr((S8*)CU_IP_V4_ADDR, &ipv4_cu);
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].cuIpAddr.ipV4Addr = ipv4_cu;
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].cuIpAddr.ipV6Pres = false;
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].cuPort = CU_SCTP_PORT_TO_DU[*numDu];
- (*numDu)++;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].cuIpAddr.ipV4Addr = ipv4_cu;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].cuIpAddr.ipV6Pres = false;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].cuPort = CU_SCTP_PORT_TO_DU[numDu];
+
+ /* EGTP Parameters */
+ memset(&ipv4_du, 0, sizeof(uint32_t));
+ cmInetAddr((S8*)DU_IP_V4_ADDR[numDu], &ipv4_du);
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].localIp.ipV4Pres = TRUE;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].localIp.ipV4Addr = ipv4_cu;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].localPort = CU_EGTP_PORT[numDu];
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].destIp.ipV4Pres = TRUE;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].destIp.ipV4Addr = ipv4_du;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].destPort = DU_EGTP_PORT[numDu];
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].minTunnelId = MIN_TEID;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].currTunnelId = cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].minTunnelId;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].maxTunnelId = MAX_TEID;
+
+ (numDu)++;
}
+ cuCb.cuCfgParams.egtpParams.numDu = numDu;
+ cuCb.cuCfgParams.sctpParams.numDu = numDu;
#endif
/*PLMN*/
cuCb.cuCfgParams.rrcVersion.extRrcVer = EXT_RRC_VER;
- /* EGTP Parameters */
- cuCb.cuCfgParams.egtpParams.localIp.ipV4Pres = TRUE;
- cuCb.cuCfgParams.egtpParams.localIp.ipV4Addr = ipv4_cu;
- cuCb.cuCfgParams.egtpParams.localPort = CU_EGTP_PORT;
- cuCb.cuCfgParams.egtpParams.destIp.ipV4Pres = TRUE;
- cuCb.cuCfgParams.egtpParams.destIp.ipV4Addr = ipv4_du;
- cuCb.cuCfgParams.egtpParams.destPort = DU_EGTP_PORT;
- cuCb.cuCfgParams.egtpParams.minTunnelId = MIN_TEID;
- cuCb.cuCfgParams.egtpParams.currTunnelId = cuCb.cuCfgParams.egtpParams.minTunnelId;
- cuCb.cuCfgParams.egtpParams.maxTunnelId = MAX_TEID;
} /* End of readCuCfg */
* NUM_TUNNEL_TO_PUMP_DATA = 9, NUM_DL_PACKETS = 1.
* totalDataPacket = totalNumOfTestFlow * NUM_TUNNEL_TO_PUMP_DATA * NUM_DL_PACKETS
* totalDataPacket = [500*9*1] */
- int32_t totalNumOfTestFlow = 500;
+ int32_t totalNumOfTestFlow = 5;
while(true)
{
if(ch == 'd')
{
- /* Change #if 0 to #if 1 to take input from user */
+ /* Change #if 0 to #if 1 to take input from user */
#if 0
DU_LOG("\n EGTP --> : Enter TEID id(1..10) where DL Data to be sent\n");
scanf("%d",&teId);
-
+
if(teId > MAX_TEID || teId < MIN_TEID)
{
DU_LOG("\nERROR --> EGTP : TEID(%x) OUT Of Range",teId);
initiateInterDuHandover(sourceDuId, targetDuId, ueId);
}
+ /* Start Idle mode paging when 'p' is received from console input */
+ else if(ch == 'p')
+ {
+ uint64_t sTmsi = 0;
+ uint8_t duId = 0;
+
+ DU_LOG("\nEnter DU ID on which this UE to be pagged");
+ scanf("%d", &duId);
+ DU_LOG("\nEnter 5g-S-TMSI");
+ scanf("%lu", &sTmsi);
+
+ if(BuildAndSendPagingMsg(sTmsi, duId) != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP: Failed to build and send paging message for 5gsTmsi[%lu]\n", sTmsi);
+ }
+ continue;
+ }
}
}
/**********************************************************************
#define CU_SCTP_PORT_TO_DU (int[]){38472, 38473}
#endif
-#define DU_EGTP_PORT 39001
-#define CU_EGTP_PORT 39002
+#define DU_EGTP_PORT (int[]){39001, 39002}
+#define CU_EGTP_PORT (int[]){39003, 39004}
#define RRC_VER 0
#define EXT_RRC_VER 5
#define PLMN_MCC0 3
char cuName[CU_DU_NAME_LEN_MAX];
CuSctpParams sctpParams;
Plmn plmn;
- EgtpParams egtpParams;
+ CuEgtpParams egtpParams;
RrcVersion rrcVersion;
}CuCfgParams;
uint8_t egtpInitReq()
{
uint8_t ret = ROK;
-
+
+ egtpCb.egtpCfg = cuCb.cuCfgParams.egtpParams;
ret = cuEgtpCfgReq();
if(ret != ROK)
{
* ***********************************************************************/
S16 cuEgtpCfgReq()
{
- uint8_t ret;
-
- memcpy(&egtpCb.egtpCfg, &cuCb.cuCfgParams.egtpParams, sizeof(EgtpParams));
-
- egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
- egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
+ uint8_t ret, destIdx =0;
+
+ memcpy(&egtpCb.egtpCfg, &cuCb.cuCfgParams.egtpParams, sizeof(CuEgtpParams));
+
+ for(destIdx=0; destIdx < egtpCb.egtpCfg.numDu; destIdx++)
+ {
+ egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[destIdx].localIp.ipV4Addr);
+ egtpCb.recvTptSrvr.addr.port = EGTP_RECVR_PORT;
- egtpCb.dstCb.dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr);
- egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort;
- egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
- egtpCb.dstCb.sendTptSrvr.addr.port = egtpCb.egtpCfg.localPort;
- egtpCb.dstCb.numTunn = 0;
+ egtpCb.dstCb[destIdx].duId = destIdx+1;
+ egtpCb.dstCb[destIdx].dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[destIdx].destIp.ipV4Addr);
+ egtpCb.dstCb[destIdx].dstPort = egtpCb.egtpCfg.egtpAssoc[destIdx].destPort;
+ egtpCb.dstCb[destIdx].sendTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[destIdx].localIp.ipV4Addr);
+ egtpCb.dstCb[destIdx].sendTptSrvr.addr.port = egtpCb.egtpCfg.egtpAssoc[destIdx].localPort;
+ egtpCb.dstCb[destIdx].numTunn = 0;
- ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_UINT32_MOD, CU_APP_MEM_REG, CU_POOL);
+ ret = cmHashListInit(&(egtpCb.dstCb[destIdx].teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_UINT32_MOD, CU_APP_MEM_REG, CU_POOL);
- if(ret != ROK)
- {
- DU_LOG("\nERROR --> EGTP : TeId hash list initialization failed");
- return RFAILED;
- }
- else
- {
- DU_LOG("\nINFO --> EGTP : Configuration successful");
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : TeId hash list initialization failed");
+ return RFAILED;
+ }
+ else
+ {
+ DU_LOG("\nINFO --> EGTP : Configuration successful");
+ }
}
+ egtpCb.numDu = egtpCb.egtpCfg.numDu;
return ROK;
} /* cuEgtpCfgReq */
S16 cuEgtpSrvOpenReq(Pst *pst)
{
- uint8_t ret;
+ uint8_t ret, destIdx;
DU_LOG("\nINFO --> EGTP : Received open server request");
-
+
sockType = CM_INET_DGRAM;
if((ret = (cmInetSocket(sockType, &(egtpCb.recvTptSrvr.sockFd), protType))) != ROK)
{
DU_LOG("\nERROR --> EGTP : Failed to bind socket");
return RFAILED;
}
+
+ for(destIdx=0; destIdx < egtpCb.egtpCfg.numDu; destIdx++)
+ {
+ if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb[destIdx].sendTptSrvr.sockFd), protType)) != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : Failed to open UDP socket");
+ return RFAILED;
+ }
- if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb.sendTptSrvr.sockFd), protType)) != ROK)
- {
- DU_LOG("\nERROR --> EGTP : Failed to open UDP socket");
- return RFAILED;
- }
-
- ret = cmInetBind(&(egtpCb.dstCb.sendTptSrvr.sockFd), &(egtpCb.dstCb.sendTptSrvr.addr));
- if(ret != ROK)
- {
- DU_LOG("\nERROR --> EGTP : Failed to bind socket");
- return RFAILED;
- }
-
- /* TODO: set socket options */
+ ret = cmInetBind(&(egtpCb.dstCb[destIdx].sendTptSrvr.sockFd), &(egtpCb.dstCb[destIdx].sendTptSrvr.addr));
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : Failed to bind socket");
+ return RFAILED;
+ }
- DU_LOG("\nINFO --> EGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd,\
- egtpCb.dstCb.sendTptSrvr.sockFd.fd);
+ /* TODO: set socket options */
+
+ DU_LOG("\nINFO --> EGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd,\
+ egtpCb.dstCb[destIdx].sendTptSrvr.sockFd.fd);
+ }
return ROK;
} /* cuEgtpSrvOpenReq */
*
* ***************************************************************************/
-S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt)
+S16 cuEgtpTnlMgmtReq(uint32_t duId, EgtpTnlEvt tnlEvt)
{
S8 ret;
{
case EGTP_TNL_MGMT_ADD:
{
- ret = cuEgtpTnlAdd(tnlEvt);
+ ret = cuEgtpTnlAdd(duId, tnlEvt);
break;
}
case EGTP_TNL_MGMT_MOD:
{
- ret = cuEgtpTnlMod(tnlEvt);
+ ret = cuEgtpTnlMod(duId, tnlEvt);
break;
}
case EGTP_TNL_MGMT_DEL:
{
- ret = cuEgtpTnlDel(tnlEvt);
+ ret = cuEgtpTnlDel(duId, tnlEvt);
break;
}
default:
* RFAILED - failure
*
* ***************************************************************************/
-S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt)
+S16 cuEgtpTnlAdd(uint32_t duId, EgtpTnlEvt tnlEvt)
{
S16 ret;
EgtpTeIdCb *teidCb;
teidCb->teId = tnlEvt.lclTeid;
teidCb->remTeId = tnlEvt.remTeid;
- ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t));
+ ret = cmHashListInsert(&(egtpCb.dstCb[duId-1].teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t));
if(ret != ROK)
{
DU_LOG("\nERROR --> EGTP : Failed to insert in hash list");
CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb));
return RFAILED;
}
- egtpCb.dstCb.numTunn++;
+ egtpCb.dstCb[duId-1].numTunn++;
/* Encoding pre-defined header */
memset(&preDefHdr, 0, sizeof(EgtpMsgHdr));
* RFAILED - failure
*
* ***************************************************************************/
-S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt)
+S16 cuEgtpTnlMod(uint32_t duId, EgtpTnlEvt tnlEvt)
{
#if 0
S16 ret;
DU_LOG("\nDEBUG --> CU_STUB : Tunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nDEBUG --> CU_STUBTunnel id not found");
* RFAILED - failure
*
* ***************************************************************************/
-S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt)
+S16 cuEgtpTnlDel(uint32_t duId, EgtpTnlEvt tnlEvt)
{
EgtpTeIdCb *teidCb = NULLP;
DU_LOG("\nDEBUG --> EGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
return RFAILED;
}
- cmHashListDelete(&(egtpCb.dstCb.teIdLst), (PTR)teidCb);
+ cmHashListDelete(&(egtpCb.dstCb[duId-1].teIdLst), (PTR)teidCb);
CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb));
- egtpCb.dstCb.numTunn--;
+ egtpCb.dstCb[duId-1].numTunn--;
return ROK;
} /* cuEgtpTnlDel */
} /* egtpEncodeHdr */
+/*******************************************************************
+ *
+ * @brief This handles the any EGTP received message
+ *
+ * @details
+ *
+ * Function : cuEgtpHdlRecvMsg
+ *
+ * Functionality:
+ * This handles the any EGTP received message
+ *
+ * @params[in] Message Buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
S16 cuEgtpHdlRecvMsg(Buffer *mBuf)
{
/*Decoding of EGTP message header */
}
+/*******************************************************************
+ *
+ * @brief Decodes message header
+ *
+ * @details
+ *
+ * Function : cuEgtpDecodeHdr
+ *
+ * Functionality:
+ * Decodes EGTP message haeder
+ *
+ * @params[in] Message Buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
S16 cuEgtpDecodeHdr(Buffer *mBuf)
{
EgtpMsg egtpMsg;
} /* End of cuEgtpDecodeHdr */
+/*******************************************************************
+ *
+ * @brief This function is responsible to build application message, encode EGTP
+ * header to it and send to DU over tunnel (teId)
+ *
+ * @details
+ *
+ * Function : cuEgtpDatReq
+ *
+ * Functionality:
+ * function is responsible to build application message, encode EGTP
+ * header to it and send to DU over tunnel (teId)
+ *
+ * @params[in] uint8_t teId
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
uint16_t cuEgtpDatReq(uint8_t teId)
{
- uint8_t ret = ROK, cnt = 0;
+ uint8_t ret = ROK, cnt = 0, duId =0;
EgtpMsg egtpMsg;
egtpMsg.msgHdr.teId = teId;
DU_LOG("\nERROR --> EGTP : DRB not created");
return RFAILED ;
}
- /* Build Application message that is supposed to come from app to egtp */
- ret = BuildAppMsg(&egtpMsg);
- if(ret != ROK)
+ for(duId = 1; duId<=egtpCb.numDu; duId++)
{
- DU_LOG("\nERROR --> EGTP : Failed to build App Msg");
- return RFAILED;
- }
+ /* Build Application message that is supposed to come from app to egtp */
+ ret = BuildAppMsg(duId, &egtpMsg);
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : Failed to build App Msg");
+ return RFAILED;
+ }
- /* Encode EGTP header to build final EGTP message */
- ret = BuildEgtpMsg(&egtpMsg);
- if(ret != ROK)
- {
- DU_LOG("\nERROR --> EGTP : Failed to build EGTP Msg");
- return RFAILED;
+ /* Encode EGTP header to build final EGTP message */
+ ret = BuildEgtpMsg(duId, &egtpMsg);
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : Failed to build EGTP Msg");
+ return RFAILED;
+ }
+ cuEgtpSendMsg(duId, egtpMsg.msg);
+ ODU_PUT_MSG_BUF(egtpMsg.msg);
}
- cuEgtpSendMsg(egtpMsg.msg);
- ODU_PUT_MSG_BUF(egtpMsg.msg);
-
return ROK;
}
-S16 BuildAppMsg(EgtpMsg *egtpMsg)
+/*******************************************************************
+ *
+ * @brief Builds application message to be sent to DU in DL path
+ *
+ * @details
+ *
+ * Function : BuildAppMsg
+ *
+ * Functionality:
+ * Builds application message to be sent to DU in DL path
+ *
+ * @params[in] uint32_t duId,EGTP message
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+S16 BuildAppMsg(uint32_t duId, EgtpMsg *egtpMsg)
{
char data[1215] = "In telecommunications, 5G is the fifth generation technology standard for broadband cellular"
" networks, which cellular phone companies began deploying worldwide in 2019, and is the planned successor to the 4G "
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
ipv4Hdr.hdrVer = 0x45;
ipv4Hdr.proto = 1;
- ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
- ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr);
+ ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[duId-1].localIp.ipV4Addr);
+ ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[duId-1].destIp.ipV4Addr);
/* Packing IPv4 header into buffer */
S16 ret, cnt, idx;
return ret;
}
-S16 BuildEgtpMsg(EgtpMsg *egtpMsg)
+/*******************************************************************
+ *
+ * @brief Encodes EGTP header to application message to send to DU
+ *
+ * @details
+ *
+ * Function : BuildEgtpMsg
+ *
+ * Functionality:
+ * Encodes EGTP header to application message to send to DU
+ *
+ * @params[in] uint32_t duId,EGTP message
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+S16 BuildEgtpMsg(uint32_t duId, EgtpMsg *egtpMsg)
{
EgtpTeIdCb *teidCb = NULLP;
MsgLen tPduSize;
uint32_t msgLen;
EgtpMsgHdr *msgHdr;
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(egtpMsg->msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(egtpMsg->msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId);
return ROK;
}
-S16 cuEgtpSendMsg(Buffer *mBuf)
+/*******************************************************************
+ *
+ * @brief Send the egtp message to the destination DU
+ *
+ * @details
+ *
+ * Function : cuEgtpSendMsg
+ *
+ * Functionality:
+ * Send the egtp message to the destination DU
+ *
+ * @params[in] uint32_t duId
+ * Message Buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+S16 cuEgtpSendMsg(uint32_t duId, Buffer *mBuf)
{
S16 ret;
MsgLen txLen;
info.region = CU_APP_MEM_REG;
info.pool = CU_POOL;
- dstAddr.port = EGTP_DFLT_PORT;
- dstAddr.address = egtpCb.dstCb.dstIp;
+ dstAddr.port = EGTP_RECVR_PORT;
+ dstAddr.address = egtpCb.dstCb[duId-1].dstIp;
- ret = cmInetSendMsg(&(egtpCb.dstCb.sendTptSrvr.sockFd), &dstAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG);
+ ret = cmInetSendMsg(&(egtpCb.dstCb[duId-1].sendTptSrvr.sockFd), &dstAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG);
if(ret != ROK && ret != RWOULDBLOCK)
{
DU_LOG("\nERROR --> EGTP : Message send failure");
#ifndef __CU_STUB_EGTP_H__
#define __CU_STUB_EGTP_H__
-#define EGTP_DFLT_PORT 2152
+#define EGTP_RECVR_PORT 2152 /* As per the spec 29.281, the registered port number for GTP-U is 2152 */
#define EGTP_TNL_MGMT_ADD 1
#define EGTP_TNL_MGMT_MOD 2
#define EGTP_TNL_MGMT_DEL 3
typedef struct egtpDstCb
{
+ uint32_t duId;
CmInetIpAddr dstIp; /* destination IP */
uint16_t dstPort; /* Remote port that sends data */
EgtpTptSrvr sendTptSrvr; /* Transport server for sending UDP msg to */
CmHashListCp teIdLst; /* Tunnel Id list for this destination */
}EgtpDstCb;
-typedef struct egtpParams
+typedef struct egtpAssoc
{
SctpIpAddr localIp;
uint16_t localPort;
uint32_t currTunnelId;
uint32_t minTunnelId;
uint32_t maxTunnelId;
-}EgtpParams;
+}EgtpAssoc;
+
+typedef struct cuEgtpParams
+{
+ uint8_t numDu;
+ EgtpAssoc egtpAssoc[MAX_DU_SUPPORTED];
+}CuEgtpParams;
typedef struct egtpGlobalCb
{
- EgtpParams egtpCfg; /* EGTP configuration */
+ CuEgtpParams egtpCfg; /* EGTP configuration */
EgtpTptSrvr recvTptSrvr; /* Transport server for receiving UDP msg */
- EgtpDstCb dstCb; /* Destination endpoint */
+ uint8_t numDu;
+ EgtpDstCb dstCb[MAX_DU_SUPPORTED]; /* Destination endpoint */
uint8_t gCntPdu[MAX_TEID+1]; /* Maintaining PDU count for each bearer */
}EgtpGlobalCb;
EgtpGlobalCb egtpCb; /* EGTP global control block */
S16 egtpActvInit();
S16 cuEgtpCfgReq();
S16 cuEgtpSrvOpenReq();
-S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt);
-S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt);
-S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt);
-S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt);
+S16 cuEgtpTnlMgmtReq(uint32_t duId,EgtpTnlEvt tnlEvt);
+S16 cuEgtpTnlAdd(uint32_t duId, EgtpTnlEvt tnlEvt);
+S16 cuEgtpTnlMod(uint32_t duId,EgtpTnlEvt tnlEvt);
+S16 cuEgtpTnlDel(uint32_t duId,EgtpTnlEvt tnlEvt);
S16 cuEgtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrIdx);
S16 cuEgtpHdlRecvMsg(Buffer *mBuf);
uint16_t cuEgtpDatReq(uint8_t teId);
-S16 BuildAppMsg(EgtpMsg *egtpMsg);
-S16 BuildEgtpMsg(EgtpMsg *egtpMsg);
-S16 cuEgtpSendMsg(Buffer *mBuf);
+S16 BuildAppMsg(uint32_t duId, EgtpMsg *egtpMsg);
+S16 BuildEgtpMsg(uint32_t duId, EgtpMsg *egtpMsg);
+S16 cuEgtpSendMsg(uint32_t duId, Buffer *mBuf);
S16 cuEgtpDecodeHdr(Buffer *mBuf);
#endif
memset(&f1PollParams, 0, sizeof(sctpSockPollParams));
- egtpFromAddr.port = egtpCb.dstCb.dstPort;
- egtpFromAddr.address = egtpCb.dstCb.dstIp;
/* All sockets are non-blocking */
timeout = 0;
}
/* Receiving EGTP data */
- egtpBufLen = -1;
- ret = cmInetRecvMsg(&(egtpCb.recvTptSrvr.sockFd), &egtpFromAddr, &memInfo, &egtpBuf, &egtpBufLen, CM_INET_NO_FLAG);
- if(ret == ROK && egtpBuf != NULLP)
+ for(destIdx = 0; destIdx < egtpCb.numDu; destIdx++)
{
- DU_LOG("\nINFO --> EGTP : Received UL Message [%ld]\n", numMsgRcvd+1);
- numMsgRcvd++;
- //ODU_PRINT_MSG(egtpBuf, 0 ,0);
- cuEgtpHdlRecvMsg(egtpBuf);
+
+ egtpFromAddr.port = egtpCb.dstCb[destIdx].dstPort;
+ egtpFromAddr.address = egtpCb.dstCb[destIdx].dstIp;
+ egtpBufLen = -1;
+ ret = cmInetRecvMsg(&(egtpCb.recvTptSrvr.sockFd), &egtpFromAddr, &memInfo, &egtpBuf, &egtpBufLen, CM_INET_NO_FLAG);
+ if(ret == ROK && egtpBuf != NULLP)
+ {
+ DU_LOG("\nINFO --> EGTP : Received UL Message [%ld] from DUid %d\n", numMsgRcvd+1, egtpCb.dstCb[destIdx].duId);
+ numMsgRcvd++;
+ //ODU_PRINT_MSG(egtpBuf, 0 ,0);
+ cuEgtpHdlRecvMsg(egtpBuf);
+ }
}
};
return (ret);
uint16_t cuPort;
}SctpAssocInfo;
-typedef struct CuSctpParams
+typedef struct cuSctpParams
{
uint8_t numDu;
SctpAssocInfo sctpAssoc[MAX_DU_SUPPORTED];
#include "du_mgr.h"
#include "du_utils.h"
#include "du_cell_mgr.h"
+#include "PCCH-Config.h"
#ifdef O1_ENABLE
{
DuCellCb *cellCb = NULLP;
-#ifndef O1_ENABLE
-
- /*Note: Static Configuration, when O1 is not configuring the RRM policy*/
- RrmPolicy *rrmPolicy;
- DU_ALLOC(rrmPolicy, sizeof(RrmPolicy));
- rrmPolicy->rsrcType = RSRC_PRB;
- rrmPolicy->numMemberList = 1;
- DU_ALLOC(rrmPolicy->memberList, sizeof(PolicyMemberList *));
- DU_ALLOC(rrmPolicy->memberList[0], sizeof(PolicyMemberList));
-
- memset(&rrmPolicy->memberList[0]->plmn, 0, sizeof(Plmn));
- rrmPolicy->memberList[0]->snssai.sst = 1;
- rrmPolicy->memberList[0]->snssai.sd[0] = 2;
- rrmPolicy->memberList[0]->snssai.sd[1] = 3;
- rrmPolicy->memberList[0]->snssai.sd[2] = 4;
- rrmPolicy->policyMinRatio = 30;
- rrmPolicy->policyMaxRatio = 90;
- rrmPolicy->policyDedicatedRatio = 10;
-#endif
-
if(cellId->cellId <=0 || cellId->cellId > MAX_NUM_CELL)
{
DU_LOG("\nERROR --> DU APP : Invalid Cell Id %d in duHandleCellUpInd()", cellId->cellId);
cellCb->cellStatus = ACTIVATED;
gCellStatus = CELL_UP;
-#ifdef O1_ENABLE
if(duCfgParam.tempSliceCfg.rrmPolicy)
BuildAndSendSliceConfigReq(duCfgParam.tempSliceCfg.rrmPolicy, duCfgParam.tempSliceCfg.totalRrmPolicy, duCfgParam.tempSliceCfg.totalSliceCount);
+#ifdef O1_ENABLE
DU_LOG("\nINFO --> DU APP : Raise cell UP alarm for cell id=%d", cellId->cellId);
raiseCellAlrm(CELL_UP_ALARM_ID, cellId->cellId);
setCellOpState(cellId->cellId, ENABLED, ACTIVE);
-#else
- BuildAndSendSliceConfigReq(&rrmPolicy,1, rrmPolicy->numMemberList);
#endif
}
return ROK;
}
+/*******************************************************************
+ * @brief fill paging information of a UE belongs to a particular cell
+ *
+ * @details
+ *
+ * Function : FillPagingInfoInCellCb
+ *
+ * Functionality: fill paging information of a UE in DuCellCb
+ *
+ * @params[in] DuCellCb* cellCb, uint8_t ueId,
+ * DuPagingMsg rcvdF1apPagingParam
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t FillPagingInfoInCellCb(DuCellCb* cellCb, DuPagingMsg *rcvdF1apPagingParam)
+{
+ uint8_t ns = 0;
+ uint16_t T=0, N=0, pagingFrame = 0, n = 0;
+ uint16_t currentSfn = 0, sfn = 0, newSfn = 0;
+ PcchCfg duPcchCfg;
+
+ DU_LOG("\nINFO --> DU APP : Start filling paging parameters in DuCellCb");
+ if(cellCb)
+ {
+ /* calculate paging frame and paging offset */
+ duPcchCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg;
+ rcvdF1apPagingParam->pagingFrameOffset = duPcchCfg.pageFrameOffset;
+ ns = duPcchCfg.ns;
+
+ /*
+ * Fill the Value of T (DRX cycle of the UE)
+ * T = min(UE Specific DRX value allocated by upper layers, default DRX
+ * broadcast in System Information) */
+ if((rcvdF1apPagingParam->pagingDrxPres) && (duPcchCfg.dfltPagingCycle > rcvdF1apPagingParam->pagingDrx))
+ {
+ T = rcvdF1apPagingParam->pagingDrx;
+ }
+ else
+ {
+ T = duPcchCfg.dfltPagingCycle;
+ }
+ rcvdF1apPagingParam->T = T;
+
+ /* N= number of total paging frames in T */
+
+ switch(duPcchCfg.nAndPagingFrmOffsetType)
+ {
+ case PCCH_Config__nAndPagingFrameOffset_PR_oneT:
+ N = T;
+ break;
+ case PCCH_Config__nAndPagingFrameOffset_PR_halfT:
+ N = T/2;
+ break;
+ case PCCH_Config__nAndPagingFrameOffset_PR_quarterT:
+ N = T/4;
+ break;
+ case PCCH_Config__nAndPagingFrameOffset_PR_oneEighthT:
+ N = T/8;
+ break;
+ case PCCH_Config__nAndPagingFrameOffset_PR_oneSixteenthT:
+ N = T/16;
+ break;
+ default:
+ N = T;
+ break;
+ }
+
+ /* calculate the Value of pagingFrame */
+ /*Refer: 38.304 Sec 7.1: (SFN + PF_offset) mod T = (T div N)*(UE_ID mod N)*/
+ //RHS of above formula
+ pagingFrame = (T / N) * ((rcvdF1apPagingParam->ueId) % N);
+
+ //LHS of above formula
+ if(pagingFrame)
+ {
+ pagingFrame = (pagingFrame - rcvdF1apPagingParam->pagingFrameOffset)%T;
+ }
+ else /*Paging Frame = 0 so thus PF will be calculated on Paging Cycle*/
+ {
+ pagingFrame = (T - rcvdF1apPagingParam->pagingFrameOffset)%T;
+ }
+
+ /*Paging Frame(SFN for Paging) has to be determined from current SFN. */
+ /*For eg: If T =128, PF(Calculated above) = 20; SFN can be 20,148,276,...
+ * If currSFN is running as 200 then (newSFN % T) == (T/N)*(UE_ID%N)
+ *Thus SFN at which paging has to be sent needs to be delayed and newSFN = 276*/
+
+ currentSfn = cellCb->currSlotInfo.sfn;
+
+ /*Multiplication Factor(x) to find the next best SFN to process paging*/
+
+ /*Below calculation will determine in which nth cycle of T (DRX cycle),new PF
+ * may fall(Delayed one)*/
+ if(currentSfn > pagingFrame)
+ {
+ n = ((currentSfn - pagingFrame) / T) + 1;
+ }
+ else
+ {
+ n = ((pagingFrame - currentSfn) / T) + 1;
+ }
+
+ newSfn = pagingFrame + T * n;
+
+ /*When pagingFrame is future from currSFN then pagingFrame will be used
+ * else pagingFrame is delayed thus newSFN will be used.*/
+ if(currentSfn <= pagingFrame)
+ {
+ if(pagingFrame > currentSfn + PAGING_SCHED_DELTA)
+ {
+ sfn = pagingFrame;
+ }
+ else
+ {
+ sfn = newSfn;
+ }
+ }
+ else
+ {
+
+ if(newSfn > currentSfn + PAGING_SCHED_DELTA)
+ {
+ sfn = newSfn;
+ }
+ else /*If newSFN is near to currSFN then delay it more by T*/
+ {
+ newSfn = newSfn + T;
+ sfn = newSfn;
+ }
+ }
+ rcvdF1apPagingParam->pagingFrame = (sfn % 1024);
+ rcvdF1apPagingParam->i_s = ((uint32_t)(floor(rcvdF1apPagingParam->ueId / N)) % ns);
+
+ DU_LOG("\nINFO --> DU APP : Successfully filled paging parameter in DuCellCb");
+ memcpy(&cellCb->tmpPagingInfoOfUe, rcvdF1apPagingParam, sizeof(DuPagingMsg));
+ }
+ else
+ {
+ DU_LOG("\nINFO --> DU APP : FillPagingInfoInCellCb(): Received null pointer");
+ return RFAILED;
+ }
+ return ROK;
+}
+
+
/**********************************************************************
End of file
**********************************************************************/
uint8_t duGetCellCb(uint16_t cellId, DuCellCb **cellCb);
uint8_t BuildAndSendSliceConfigReq(RrmPolicy *rrmPolicy[], uint8_t totalRrrmPolicy, uint8_t totalSliceCfgReq);
uint8_t BuildAndSendSliceReCfgReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceReCfg);
+uint8_t FillPagingInfoInCellCb(DuCellCb* cellCb, DuPagingMsg *rcvdF1apPagingParam);
#endif
/**********************************************************************
End of file
#include "du_cfg.h"
#include "du_mgr.h"
#include "du_utils.h"
+#include "du_f1ap_conversions.h"
#include "OCTET_STRING.h"
#include "BIT_STRING.h"
#include "odu_common_codec.h"
duCfgParam.macCellCfg.sib1Cfg.searchSpaceZeroIndex = SEARCHSPACE_0_INDEX;
duCfgParam.macCellCfg.sib1Cfg.sib1Mcs = DEFAULT_MCS;
- GET_NUM_PAGING_OCC(duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg.ns,
- duCfgParam.macCellCfg.sib1Cfg.pagingCfg.numPO);
- if(duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg.firstPDCCHMontioringType != \
- PCCH_Config__firstPDCCH_MonitoringOccasionOfPO_PR_NOTHING)
+ duCfgParam.macCellCfg.sib1Cfg.pagingCfg.numPO = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg.ns;
+ if((duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg.firstPDCCHMontioringType != \
+ PCCH_Config__firstPDCCH_MonitoringOccasionOfPO_PR_NOTHING) && (duCfgParam.macCellCfg.sib1Cfg.pagingCfg.numPO != 0))
{
duCfgParam.macCellCfg.sib1Cfg.pagingCfg.poPresent = TRUE;
memcpy(duCfgParam.macCellCfg.sib1Cfg.pagingCfg.pagingOcc,
memcpy(duCfgParam.macCellCfg.plmnInfoList.snssai[sliceIdx], taiSliceSuppLst->snssai[sliceIdx], sizeof(Snssai));
}
}
+
+#ifndef O1_ENABLE
+
+ /*Note: Static Configuration, when O1 is not configuring the RRM policy*/
+ RrmPolicyList rrmPolicy;
+ rrmPolicy.id[0] = 1;
+ rrmPolicy.resourceType = PRB;
+ rrmPolicy.rRMMemberNum = 1;
+ memcpy(rrmPolicy.rRMPolicyMemberList[0].mcc,duCfgParam.macCellCfg.plmnInfoList.plmn.mcc, 3*sizeof(uint8_t));
+ memcpy(rrmPolicy.rRMPolicyMemberList[0].mnc,duCfgParam.macCellCfg.plmnInfoList.plmn.mnc, 3*sizeof(uint8_t));
+ rrmPolicy.rRMPolicyMemberList[0].sst = 1;
+ rrmPolicy.rRMPolicyMemberList[0].sd[0] = 2;
+ rrmPolicy.rRMPolicyMemberList[0].sd[1] = 3;
+ rrmPolicy.rRMPolicyMemberList[0].sd[2] = 4;
+ rrmPolicy.rRMPolicyMaxRatio = 90;
+ rrmPolicy.rRMPolicyMinRatio = 30;
+ rrmPolicy.rRMPolicyDedicatedRatio = 10;
+
+ cpyRrmPolicyInDuCfgParams(&rrmPolicy, 1, &duCfgParam.tempSliceCfg);
+
+#endif
return ROK;
}
BCCH_Config__modificationPeriodCoeff_n16;
/* Configuring PCCH Config for SIB1 */
- pcchCfg.dfltPagingCycle = PagingCycle_rf256;
+ pcchCfg.dfltPagingCycle = convertPagingCycleEnumToValue(PagingCycle_rf256);
pcchCfg.nAndPagingFrmOffsetType = PCCH_Config__nAndPagingFrameOffset_PR_oneT;
pcchCfg.pageFrameOffset = 0;
- pcchCfg.ns = PCCH_Config__ns_one;
+ pcchCfg.ns = convertNsEnumToValue(PCCH_Config__ns_one);
pcchCfg.firstPDCCHMontioringType = PCCH_Config__firstPDCCH_MonitoringOccasionOfPO_PR_sCS30KHZoneT_SCS15KHZhalfT;
memset(pcchCfg.firstPDCCHMontioringInfo, 0, sizeof(uint16_t));
pcchCfg.firstPDCCHMontioringInfo[0] = 44;
* RFAILED - failure
*
* ****************************************************************/
-#ifdef O1_ENABLE
uint8_t cpyRrmPolicyInDuCfgParams(RrmPolicyList rrmPolicy[], uint8_t policyNum, CopyOfRecvdSliceCfg *tempSliceCfg)
{
uint8_t policyIdx = 0, memberListIdx = 0, count = 0;
}
return ROK;
}
-#endif
/*******************************************************************
*
* @brief Reads config and posts message to du_app on completion
#endif
#define DU_EGTP_PORT 39001
-#define CU_EGTP_PORT 39002
+#define CU_EGTP_PORT 39003
#define NR_PCI 1
#define NR_CELL_ID 1
typedef struct pcchCfg
{
- uint8_t dfltPagingCycle; /* Default paging cycle */
+ uint16_t dfltPagingCycle; /* Default paging cycle */
uint8_t nAndPagingFrmOffsetType; /*Number of PagingFrames in PagingCycle defined in terms of T.*/
uint8_t pageFrameOffset; /* Paging Frame offset */
uint8_t ns; /* Number of paging occassions in paging frame */
char *f1MsgRspBuf;
}F1SetupMsg;
+
+#ifndef O1_ENABLE
+//RRM POLICY STRUCT
+
+typedef struct rRMPolicyMemberList
+{
+ uint8_t mcc[3];
+ uint8_t mnc[3];
+ uint8_t sd[3];
+ uint8_t sst;
+}RRMPolicyMemberList;
+
+typedef enum
+{
+ PRB,
+ PRB_UL,
+ PRB_DL,
+ RRC,
+ DRB
+}RrmResourceType;
+
+typedef struct rrmPolicyList
+{
+ char id[1];
+ RrmResourceType resourceType;
+ uint8_t rRMMemberNum;
+ RRMPolicyMemberList rRMPolicyMemberList[2];
+ uint8_t rRMPolicyMaxRatio;
+ uint8_t rRMPolicyMinRatio;
+ uint8_t rRMPolicyDedicatedRatio;
+}RrmPolicyList;
+#endif
+
DuCfgParams duCfgParam;
/*function declarations */
uint8_t readCfg();
uint8_t duReadCfg();
uint16_t calcSliv(uint8_t startSymbol, uint8_t lengthSymbol);
-
-#ifdef O1_ENABLE
uint8_t cpyRrmPolicyInDuCfgParams(RrmPolicyList rrmPolicy[], uint8_t policyNum, CopyOfRecvdSliceCfg *tempSliceCfg);
-#endif
#endif /* __DU_CONFIG_H__ */
{
uint8_t unused = 0;
uint8_t byteSize = 4;
- uint8_t val = 1;
+ uint8_t gnbId = 1;
uint8_t ret = ROK;
/* Allocate Buffer size */
else
{
buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn, \
- gNbId->global_gNB_ID.plmn_id.buf);
+ gNbId->global_gNB_ID.plmn_id.buf);
/* fill gND Id */
gNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID;
/* Allocate Buffer size */
gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = byteSize * sizeof(uint8_t);
gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = NULLP;
DU_ALLOC(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf, \
- gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
+ gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size);
if(gNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf == NULLP)
{
- DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
- ret = RFAILED;
+ DU_LOG("\nERROR --> E2AP: Memory allocation failed for gnb buffer");
+ ret = RFAILED;
}
else
{
- fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, val);
+ fillBitString(&gNbId->global_gNB_ID.gnb_id.choice.gnb_ID, unused, byteSize, gnbId);
}
}
return ret;
memcpy(&egtpCb.egtpCfg, &egtpCfg, sizeof(EgtpConfig));
egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
- egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
+ egtpCb.recvTptSrvr.addr.port = EGTP_RECVR_PORT;
egtpCb.dstCb.dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr);
egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort;
info.region = DU_APP_MEM_REGION;
info.pool = DU_POOL;
- dstAddr.port = EGTP_DFLT_PORT;
+ dstAddr.port = EGTP_RECVR_PORT;
dstAddr.address = egtpCb.dstCb.dstIp;
ret = cmInetSendMsg(&(egtpCb.dstCb.sendTptSrvr.sockFd), &dstAddr, &info, \
#ifndef __DU_EGTP_H__
#define __DU_EGTP_H__
-#define EGTP_DFLT_PORT 2152
+#define EGTP_RECVR_PORT 2152 /* As per the spec 29.281, the registered port number for GTP-U is 2152 */
#define EGTP_MAX_HDR_LEN 40
#define EGTP_MAX_MSG_RECV 10
* its corresponding values used in DU and vice-versa */
#include "common_def.h"
-#include "SN-FieldLengthUM.h"
-#include "SN-FieldLengthAM.h"
-#include "T-PollRetransmit.h"
-#include "PollPDU.h"
-#include "PollByte.h"
-#include "UL-AM-RLC.h"
-#include "T-Reassembly.h"
-#include "T-StatusProhibit.h"
-#include "DL-AM-RLC.h"
-#include "RLC-Config.h"
-#include "RLC-BearerConfig.h"
#include "BSR-Config.h"
-#include "PUCCH-Resource.h"
-#include "du_app_rlc_inf.h"
+#include "du_f1ap_conversions.h"
/************************************************************************
*
}
}
+/************************************************************************
+ *
+ * @brief Converts actual values into enum value of Paging DRX cycle
+ *
+ * @details
+ *
+ * Function : convertPagingCycleValueToEnum
+ *
+ * Functionality: As per Spec 38.331,
+ * Converts Actual values into enum value of Paging DRX cycle
+ *
+ *
+ * @params[in] Actual value of PagingDRX
+ * @return Enum value of DRX cycle
+ *
+ * **********************************************************************/
+e_PagingDRX convertPagingCycleValueToEnum(uint16_t pagingDrxCycle)
+{
+ switch(pagingDrxCycle)
+ {
+ case 32:
+ return PagingDRX_v32;
+ case 64:
+ return PagingDRX_v64;
+ case 128:
+ return PagingDRX_v128;
+ case 256:
+ return PagingDRX_v256;
+ default:
+ return PagingDRX_v32;
+ }
+}
+
+/************************************************************************
+ *
+ * @brief Converts enum values into actual value of Paging DRX cycle
+ *
+ * @details
+ *
+ * Function : convertPagingCycleEnumToValue
+ *
+ * Functionality: As per Spec 38.331,
+ * Converts enum values into actual value of Paging DRX cycle
+ *
+ *
+ * @params[in] Enum value of PagingDRX
+ * @return Actual value of DRX cycle
+ * Note: Returning the MAX value in case of Incorrect Enum Value as DRX
+ * cycle is MIN of Various DRX cycle
+ *
+ * **********************************************************************/
+uint16_t convertPagingCycleEnumToValue(e_PagingDRX pagingDrx)
+{
+ switch(pagingDrx)
+ {
+ case PagingDRX_v32:
+ return 32;
+ case PagingDRX_v64:
+ return 64;
+ case PagingDRX_v128:
+ return 128;
+ case PagingDRX_v256:
+ return 256;
+ default:
+ return 256;
+ }
+}
+/************************************************************************
+ *
+ * @brief Converts enum values into actual value of Num of Paging Ocassions
+ *
+ * @details
+ *
+ * Function : convertPagingOccEnumToValue
+ *
+ * Functionality: As per Spec 38.331,
+ * Converts enum values into actual value of Num of Paging Ocassion
+ *
+ *
+ * @params[in] Enum value of Ns
+ * @return Actual value of Num of Paging Ocassions
+ *
+ * **********************************************************************/
+uint8_t convertNsEnumToValue(e_PCCH_Config__ns Ns)
+{
+ switch(Ns)
+ {
+ case PCCH_Config__ns_four:
+ return 4;
+ case PCCH_Config__ns_two:
+ return 2;
+ case PCCH_Config__ns_one:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+/************************************************************************
+ *
+ * @brief Converts actual values into enum value of Num of Paging Ocassions
+ *
+ * @details
+ *
+ * Function : convertNsValueToEnum
+ *
+ * Functionality: As per Spec 38.331,
+ * Converts actual values into enum value of Num of Paging Ocassions
+ *
+ *
+ * @params[in] Actual value of Num of Paging Ocassions
+ * @return Enum value of Ns
+ *
+ * **********************************************************************/
+e_PCCH_Config__ns convertNsValueToEnum(uint8_t numPO)
+{
+ switch(numPO)
+ {
+ case 1:
+ return PCCH_Config__ns_one;
+ case 2:
+ return PCCH_Config__ns_two;
+ case 4:
+ return PCCH_Config__ns_four;
+ default:
+ return PCCH_Config__ns_one;
+ }
+}
/**********************************************************************
End of file
**********************************************************************/
/* This file contains definitions of F1AP conversion functions */
+#include "RLC-BearerConfig.h"
+#include "RLC-Config.h"
+#include "SN-FieldLengthAM.h"
+#include "SN-FieldLengthUM.h"
+#include "T-PollRetransmit.h"
+#include "PollPDU.h"
+#include "PollByte.h"
+#include "T-Reassembly.h"
+#include "T-StatusProhibit.h"
+#include "PUCCH-Resource.h"
+#include "PagingDRX.h"
+#include "PCCH-Config.h"
+#include "du_app_rlc_inf.h"
+
RLC_BearerConfig__servedRadioBearer_PR covertRbTypeFromIntEnumToRrcEnum(RlcRbType rbType);
RLC_Config_PR covertRlcModeFromIntEnumToRrcEnum(RlcMode mode);
SN_FieldLengthAM_t covertAmSnLenFromIntEnumToRrcEnum(SnLenAm snLen);
SnLenUm covertUmSnLenFromRrcEnumToIntEnum(SN_FieldLengthUM_t snLen);
T_PollRetransmit_t covertPollRetxTmrValueToEnum(uint16_t pollRetxTmr);
uint16_t covertPollRetxTmrEnumToValue(uint8_t pollRetxTmrCfg);
-PollPDU_t covertPollPduValueToEnum(int16_t pollPdu);
+PollPDU_t covertPollPduValueToEnum(int32_t pollPdu);
int32_t covertPollPduEnumToValue(uint8_t pollPduCfg);
PollByte_t covertPollByteValueToEnum(int32_t pollByte);
int32_t covertPollByteEnumToValue(uint16_t pollBytesCfg);
long convertBsrRetxTmrValueToEnum(uint16_t retxTmr);
long convertLcSrDelayTmrValueToEnum(uint16_t delayTimer);
+e_PagingDRX convertPagingCycleValueToEnum(uint16_t pagingDrxCycle);
+uint16_t convertPagingCycleEnumToValue(e_PagingDRX pagingDrx);
+uint8_t convertNsEnumToValue(e_PCCH_Config__ns Ns);
+e_PCCH_Config__ns convertNsValueToEnum(uint8_t numPO);
+
/**********************************************************************
End of file
**********************************************************************/
#include "du_sys_info_hdl.h"
#include "du_e2ap_msg_hdl.h"
#include "du_f1ap_conversions.h"
+#include "CNUEPagingIdentity.h"
+#include "PCCH-Config.h"
#ifdef O1_ENABLE
#include "CmInterface.h"
/* Multi CSI */
if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
{
- pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP;
+ pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP;
DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
{
freeAperDecodeUeContextReleaseCommand(f1apMsg);
return ret;
}
+
+/**************************************************************
+ *
+ * @brief free the memory allocated by aper decoder for paging
+ *
+ * @details
+ *
+ * Function : freeAperDecodePagingMsg
+ *
+ * Functionality:
+ * - free the memory allocated by aper decoder for
+ * the paging f1ap msg
+ *
+ * @params[in] Paging_t *paging
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ****************************************************************/
+void freeAperDecodePagingMsg(Paging_t *paging)
+{
+ uint8_t ieIdx, cellIdx;
+ PagingCell_ItemIEs_t *pagingCellItemIes;
+ PagingCell_Item_t *pagingCellItem;
+ PagingCell_list_t *pagingCelllist;
+
+ if(paging)
+ {
+ if(paging->protocolIEs.list.array)
+ {
+ for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
+ {
+ if(paging->protocolIEs.list.array[ieIdx])
+ {
+ switch(paging->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_UEIdentityIndexValue:
+ {
+ free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf);
+ break;
+ }
+ case ProtocolIE_ID_id_PagingIdentity:
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == \
+ CNUEPagingIdentity_PR_fiveG_S_TMSI)
+ {
+ free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf);
+ }
+ free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity);
+ }
+ }
+ break;
+ }
+ case ProtocolIE_ID_id_PagingCell_List:
+ {
+ pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
+ if(pagingCelllist->list.array)
+ {
+ for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
+ {
+ if(pagingCelllist->list.array[cellIdx])
+ {
+ pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
+ if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
+ {
+ pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
+ free(pagingCellItem->nRCGI.pLMN_Identity.buf);
+ free(pagingCellItem->nRCGI.nRCellIdentity.buf);
+ }
+ free(pagingCelllist->list.array[cellIdx]);
+ }
+ }
+ free(pagingCelllist->list.array);
+ }
+ break;
+ }
+ }
+ free(paging->protocolIEs.list.array[ieIdx]);
+ }
+ }
+ free(paging->protocolIEs.list.array);
+
+ }
+ }
+}
+
+/**************************************************************
+ *
+ * @brief processing the paging f1ap msg received from CU
+ *
+ * @details
+ *
+ * Function : procPagingMsg
+ *
+ * Functionality:
+ * - processing the paging f1ap msg received from CU
+ *
+ * @params[in] F1AP_PDU_t *f1apMsg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *
+ ****************************************************************/
+uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg)
+{
+ uint8_t ieIdx = 0, cellListIdx = 0;
+ uint16_t cellId = 0, cellIdx = 0;
+ Paging_t *paging = NULLP;
+ PagingCell_list_t *pagingCelllist = NULLP;
+ PagingCell_ItemIEs_t *pagingCellItemIes = NULLP;
+ PagingCell_Item_t *pagingCellItem = NULLP;
+ DuPagingMsg *tmpPagingParam = NULLP;
+
+ DU_LOG("\nINFO --> DU APP : Processing the Paging Message");
+ paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
+ if(paging)
+ {
+ if(paging->protocolIEs.list.array)
+ {
+ DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
+ if(tmpPagingParam == NULLP)
+ {
+ DU_LOG("\nERROR --> DU APP : Memory Allocation Failure in procPagingMsg");
+ freeAperDecodePagingMsg(paging);
+ return RFAILED;
+ }
+ for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
+ {
+ if(paging->protocolIEs.list.array[ieIdx])
+ {
+ switch(paging->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_UEIdentityIndexValue:
+ {
+ bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\
+ &tmpPagingParam->ueId);
+ break;
+ }
+
+ case ProtocolIE_ID_id_PagingIdentity:
+ {
+ switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present)
+ {
+ case PagingIdentity_PR_cNUEPagingIdentity:
+ {
+ if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
+ {
+ bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\
+ cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi);
+
+ }
+ break;
+ }
+ case PagingIdentity_PR_rANUEPagingIdentity:
+ {
+ /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/
+ break;
+ }
+ default:
+ {
+ DU_LOG("ERROR --> DU APP: Invalid UE Paging Identity, Skipping this Paging Message:");
+ continue;
+ }
+ }
+ }
+
+ case ProtocolIE_ID_id_PagingDRX:
+ {
+ tmpPagingParam->pagingDrxPres = TRUE;
+ tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX);
+ break;
+ }
+
+ case ProtocolIE_ID_id_PagingPriority:
+ {
+ tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority;
+ break;
+ }
+
+ case ProtocolIE_ID_id_PagingCell_List:
+ {
+ pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
+ if(pagingCelllist->list.array)
+ {
+ for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++)
+ {
+ if(pagingCelllist->list.array[cellListIdx])
+ {
+ pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx];
+ pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
+ bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
+ GET_CELL_IDX(cellId, cellIdx);
+ if(duCb.actvCellLst[cellIdx])
+ {
+ /* fill Ue Paging information*/
+ if(FillPagingInfoInCellCb(duCb.actvCellLst[cellIdx], tmpPagingParam)!= ROK)
+ {
+ DU_LOG("\nERROR --> DU APP : CellCb:%d not present to fill UE Paging Information",cellIdx);
+ continue;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> F1AP : CellId:%d Not in Activelist",cellId);
+ continue;
+ }
+ }
+ }
+ }
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> F1AP : Incorrect Paging IE option");
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ DU_FREE(tmpPagingParam, sizeof(DuPagingMsg));
+ freeAperDecodePagingMsg(paging);
+
+ return ROK;
+}
+
/**************************************************************
*
* @brief Handles received F1AP message and sends back response
procF1UeContextReleaseCommand(f1apMsg);
break;
}
+ case InitiatingMessage__value_PR_Paging:
+ {
+ procPagingMsg(f1apMsg);
+ break;
+ }
default:
{
DU_LOG("\nERROR --> F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
uint16_t slot;
}SlotInfo;
+typedef struct pagingMsg
+{
+ /*Note: Paging UEID is extracted from 5gSTMSI as per Spec 38.304, Sec 7.1.
+ *This is not same as DU-UE_F1AP_ID or CU_UE_F1AP_ID*/
+ uint16_t ueId; /* UE Identifier from CU*/
+
+ /*TODO: When RAN Inititated Paging will be supported then I-RNTI will be
+ * added as a choice for UE Identity along with S-TMSI*/
+ uint64_t sTmsi; /* UE Paging Identity: S-TMSI */
+ bool pagingDrxPres; /* flag to indicate paging drx present or not */
+ uint16_t pagingDrx; /* UE specific paging drx */
+ uint8_t pagPriority; /* Paging priority */
+ uint16_t pagingFrame; /* paging frame */
+ uint16_t pagingFrameOffset; /* paging offset */
+ uint8_t i_s; /* Index points to PO from the sub-frame pattern */
+ uint16_t T; /* T is DRX cycle of the UE */
+}DuPagingMsg;
+
typedef struct duCellCb
{
uint16_t cellId; /* Internal cell Id */
uint32_t numActvUes; /* Total Active UEs */
DuUeCb ueCb[MAX_NUM_UE]; /* Stores UE context */
SlotInfo currSlotInfo;
+ DuPagingMsg tmpPagingInfoOfUe; /* UE paging information */
}DuCellCb;
typedef struct duLSapCb
#include "SIB1.h"
#include "odu_common_codec.h"
#include "du_sys_info_hdl.h"
+#include "du_f1ap_conversions.h"
void FreeSib1Msg(SIB1_t *sib1Msg);
uint8_t FreqInfoUlret = RFAILED;
firstPO->present = srcPcchCfg->firstPDCCHMontioringType;
- GET_NUM_PAGING_OCC(srcPcchCfg->ns, numPO);
- if(srcPcchCfg->ns == 0)
+ numPO = srcPcchCfg->ns;
+ if(numPO == 0)
{
DU_LOG("\nINFO --> DU APP : Paging Occasions is ZERO, no need to fill further");
return ROK;
duPcchCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg;
- pcchCfg->defaultPagingCycle = duPcchCfg.dfltPagingCycle;
+ pcchCfg->defaultPagingCycle = convertPagingCycleValueToEnum(duPcchCfg.dfltPagingCycle);
pcchCfg->nAndPagingFrameOffset.present = duPcchCfg.nAndPagingFrmOffsetType;
switch(pcchCfg->nAndPagingFrameOffset.present)
{
return RFAILED;
}
}
- pcchCfg->ns = duPcchCfg.ns;
+ pcchCfg->ns = convertNsValueToEnum(duPcchCfg.ns);
DU_ALLOC(pcchCfg->firstPDCCH_MonitoringOccasionOfPO, \
sizeof(struct PCCH_Config__firstPDCCH_MonitoringOccasionOfPO));
memset(&pst, 0, sizeof(Pst));
FILL_PST_PHY_STUB_TO_LWR_MAC(pst, EVT_PHY_STUB_SLOT_IND);
-
ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf);
if(!mBuf)
{
{
uint8_t unused = 4;
uint8_t byteSize = 3;
- uint8_t val = 16;
+ uint8_t ricVal= 1;
if(ricId != NULLP)
{
ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
/* fill ric Id */
ricId->ric_ID.size = byteSize * sizeof(uint8_t);
RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
- fillBitString(&ricId->ric_ID, unused, byteSize, val);
+ fillBitString(&ricId->ric_ID, unused, byteSize, ricVal);
}
return ROK;
}
/* Start RIC-SCTP to listen on incoming connection */
sctpCfgReq();
+ /*Sleep is introduced for GDB to increase the waiting time for RIC Configuration from DUAPP*/
+ sleep(1);
sctpStartReq();
return ROK;