#include "du_utils.h"
#include<ProtocolIE-Field.h>
#include "F1AP-PDU.h"
-#include "du_f1ap_msg_hdl.h"
#include "du_mgr.h"
+#include "du_f1ap_msg_hdl.h"
#include "du_ue_mgr.h"
#ifdef EGTP_TEST
packDuRlcUlUeCreateReq, /* Light weight-loose coupling */
};
+DuDlRrcMsgToRlcFunc duSendDlRrcMsgToRlcOpts[] =
+{
+ packDlRrcMsgToRlc, /* Loose coupling */
+ RlcProcDlRrcMsgTransfer, /* Tight coupling */
+ packDlRrcMsgToRlc /* Light weight-loose coupling */
+};
+
/*******************************************************************
*
* @brief Handles EGTP data from CU
* ****************************************************************/
uint8_t duHdlEgtpDlData(EgtpMsg *egtpMsg)
{
+
/* TODO : Extract RbId/UeID/CellID/SduId from database
using tunnel id in egtp header */
DU_LOG("\nDU_APP : Processing DL data");
-
+#ifdef EGTP_TEST
Pst pst;
KwuDatReqInfo datReqInfo;
-#ifdef EGTP_TEST
datReqInfo.rlcId.rbId = RB_ID;
datReqInfo.rlcId.rbType = CM_LTE_DRB;
datReqInfo.rlcId.ueId = UE_ID;
datReqInfo.sduId = ++sduId;
datReqInfo.lcType = CM_LTE_LCH_DTCH;
-#endif
+
/* Filling pst and Sending to RLC DL */
pst.selector = ODU_SELECTOR_LWLC;
pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTKW;
+ pst.dstEnt = ENTRLC;
pst.dstInst = RLC_DL_INST;
pst.dstProcId = DU_PROC;
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
cmPkKwuDatReq(&pst, &datReqInfo, egtpMsg->msg);
- return ROK;
-}
-
-/*******************************************************************
- *
- * @brief Handles UL data and send to CU
- *
- * @details
- *
- * Function : duHdlRlcUlData
- *
- * Functionality:
- * Processes UL Data from RLC and sends to CU
- *
- * @params[in] Pointer to EGTP Message
- * @return ROK - success
- * RFAILED - failure
- *
- *****************************************************************/
-
-uint8_t duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf)
-{
- DU_LOG("\nDU_APP : Received UL Data at DU_APP");
-
- /* Send UL data to CU via EGTP */
- duSendEgtpDatInd(mBuf);
- SPutMsg(mBuf);
-
+#else
+ //duBuildAndSendDlRrcMsgToRlc();
+#endif
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t duBuildAndSendDlCcchInd(uint16_t cellId, uint16_t crnti, \
- DlCcchMsgType msgType, uint8_t *dlCcchMsg, uint16_t dlCcchMsgSize)
+uint8_t duBuildAndSendDlCcchInd(uint16_t *cellId, uint16_t *crnti, \
+ DlCcchMsgType msgType, uint16_t dlCcchMsgSize, uint8_t *dlCcchMsg)
{
uint8_t ret = ROK;
uint16_t idx2;
return RFAILED;
}
- dlCcchIndInfo->cellId = cellId;
- dlCcchIndInfo->crnti = crnti;
+ dlCcchIndInfo->cellId = *cellId;
+ dlCcchIndInfo->crnti = *crnti;
dlCcchIndInfo->msgType = msgType;
dlCcchIndInfo->dlCcchMsgLen = dlCcchMsgSize;
}
+/*******************************************************************
+ *
+ * @brief Build and Send DL RRC Message transfer to RLC
+ *
+ * @details
+ *
+ * Function : duBuildAndSendDlRrcMsgToRlc
+ *
+ * Functionality:
+ * Build and Send DL RRC Message transfer to RLC
+ *
+ * @params[in] Cell ID
+ * UE Index
+ * Logical Channgel ID
+ * RRC Message
+ * RRC Message Length
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t duBuildAndSendDlRrcMsgToRlc(uint16_t cellId, RlcUeCfg ueCfg, \
+ uint8_t lcId, bool execDup, bool deliveryStaReq, uint16_t rrcMsgLen, uint8_t *rrcMsg)
+{
+ Pst pst;
+ uint8_t ret;
+ uint8_t lcIdx;
+ RlcDlRrcMsgInfo *dlRrcMsgInfo;
+
+ DU_ALLOC_SHRABL_BUF(dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
+ if(!dlRrcMsgInfo)
+ {
+ DU_LOG("\nDU APP : Memory allocation failed for dlRrcMsgInfo in \
+ duBuildAndSendDlRrcMsgToRlc");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rrcMsg, rrcMsgLen);
+ return RFAILED;
+ }
+
+ /* Filling up the RRC msg info */
+ dlRrcMsgInfo->cellId = cellId;
+ dlRrcMsgInfo->ueIdx = ueCfg.ueIdx;
+ for(lcIdx = 0; lcIdx <= MAX_NUM_LC; lcIdx++)
+ {
+ if(ueCfg.rlcBearerCfg[lcIdx].lcId == lcId)
+ {
+ dlRrcMsgInfo->rbType = ueCfg.rlcBearerCfg[lcIdx].rbType;
+ dlRrcMsgInfo->rbId = ueCfg.rlcBearerCfg[lcIdx].rbId;
+ dlRrcMsgInfo->lcType = ueCfg.rlcBearerCfg[lcIdx].lcType;
+ dlRrcMsgInfo->lcId = ueCfg.rlcBearerCfg[lcIdx].lcId;
+ break;
+ }
+ }
+ dlRrcMsgInfo->execDup = execDup;
+ dlRrcMsgInfo->deliveryStaRpt = deliveryStaReq;
+ dlRrcMsgInfo->rrcMsg = rrcMsg;
+ dlRrcMsgInfo->msgLen = rrcMsgLen;
+
+ /* Filling post structure and sending msg */
+ memset(&pst, 0, sizeof(Pst));
+ FILL_PST_DUAPP_TO_RLC(pst, RLC_DL_INST, EVENT_DL_RRC_MSG_TRANS_TO_RLC);
+ ret = (*duSendDlRrcMsgToRlcOpts[pst.selector])(&pst, dlRrcMsgInfo);
+ if(ret != ROK)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rrcMsg, rrcMsgLen);
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
+ return RFAILED;
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Process UE context setup request from CU
+ *
+ * @details
+ *
+ * Function : procUeCintextSetupReq
+ *
+ * Functionality: Process UE context setup request from CU
+ *
+ * @params[in] F1AP message
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t procUeContextSetupReq(F1AP_PDU_t *f1apMsg)
+{
+ uint8_t ret = ROK;
+ uint8_t ieIdx, ueIdx;
+ uint8_t *rrcMsg = NULLP;
+ uint16_t rrcMsgLen;
+ uint16_t cellId, cellIdx;
+ uint32_t gnbDuUeF1apId; /* GNB DU UE F1AP ID */
+ uint32_t gnbCuUeF1apId; /* GNB CU UE F1AP ID */
+ bool deliveryStaReq = false; /* RRC msg delivery status request */
+ DuUeCb *ueCb = NULLP;
+ UEContextSetupRequest_t *ueSetReq = NULLP;
+
+ ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
+
+ /* TODO : fetch remaining values from f1ap msg */
+ for(ieIdx=0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
+ {
+ switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
+ {
+ gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
+ break;
+ }
+ case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
+ {
+ gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
+ break;
+ }
+ case ProtocolIE_ID_id_ServCellIndex:
+ {
+ cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
+ break;
+ }
+ case ProtocolIE_ID_id_RRCContainer:
+ {
+ rrcMsgLen = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size;
+ if(rrcMsgLen <= 0)
+ {
+ DU_LOG("\nDU APP : Invalid RRC Msg Length %d in Ue Ctxt Setup Req", rrcMsgLen);
+ return RFAILED;
+ }
+ DU_ALLOC_SHRABL_BUF(rrcMsg, rrcMsgLen);
+ if(!rrcMsg)
+ {
+ DU_LOG("\nDU APP : Memory allocation failed for RRC Msg in procUeCtxtSetupReq");
+ return RFAILED;
+ }
+ memcpy(rrcMsg, ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
+ rrcMsgLen);
+ break;
+ }
+ case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
+ {
+ deliveryStaReq = true;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+ cellId = duCb.actvCellLst[cellIdx]->cellId;
+ for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
+ {
+ if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId) &&
+ (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId &&
+ duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState == UE_ACTIVE))
+ {
+ ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
+ break;
+ }
+ }
+
+ /* TODO : send RB config to MAC/RLC */
+
+ /* Sending DL RRC Message to RLC */
+ if(ueIdx != MAX_NUM_UE)
+ {
+ ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, SRB1_LCID, \
+ false, deliveryStaReq, rrcMsgLen, rrcMsg);
+ }
+ else
+ {
+ DU_LOG("\nDU APP : No UE found for CuUeF1apId[%d] and DuUeF1apId[%d]", \
+ gnbCuUeF1apId, gnbDuUeF1apId);
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rrcMsg, rrcMsgLen);
+ ret = RFAILED;
+ }
+
+ return ret;
+}
+
/******************************************************************
*
* @brief Processes DL RRC Message Transfer sent by CU
uint8_t procDlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
{
DLRRCMessageTransfer_t *dlRrcMsg = NULLP;
- uint8_t *dlCcchMsg = NULLP;
- uint8_t idx, ret, srbId;
- uint16_t idx2, crnti, cellId, dlCcchMsgSize;
+ uint8_t *rrcMsgPdu = NULLP;
+ uint8_t ieIdx, ueIdx, cellIdx;
+ uint8_t ret, srbId;
+ uint16_t byteIdx, crnti, cellId, rrcMsgSize;
uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
-
+ bool execDup = false;
+ bool deliveryStaRpt = false;
+ bool ueFound = false;
+ bool ueCcchCtxtFound = false;
DU_LOG("\nDU_APP : DL RRC message transfer Recevied");
+
dlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
ret = ROK;
- for(idx=0; idx<dlRrcMsg->protocolIEs.list.count; idx++)
+ for(ieIdx=0; ieIdx<dlRrcMsg->protocolIEs.list.count; ieIdx++)
{
- switch(dlRrcMsg->protocolIEs.list.array[idx]->id)
+ switch(dlRrcMsg->protocolIEs.list.array[ieIdx]->id)
{
case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
{
- gnbCuUeF1apId = dlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
+ gnbCuUeF1apId = dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
break;
}
case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
{
- gnbDuUeF1apId = dlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
+ gnbDuUeF1apId = dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
break;
}
case ProtocolIE_ID_id_SRBID:
{
- srbId = dlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
+ srbId = dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.SRBID;
break;
}
case ProtocolIE_ID_id_ExecuteDuplication:
- break;
-
+ {
+ execDup = true;
+ break;
+ }
case ProtocolIE_ID_id_RRCContainer:
{
- if(dlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
+ if(dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size > 0)
{
- dlCcchMsgSize = dlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
- DU_ALLOC(dlCcchMsg, dlCcchMsgSize);
- for(idx2 = 0; idx2 < dlCcchMsgSize; idx2++)
+ rrcMsgSize = dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size;
+ DU_ALLOC(rrcMsgPdu, rrcMsgSize);
+ if(!rrcMsgPdu)
+ {
+ DU_LOG("\nDU_APP : Memory allocation failed in procDlRrcMsgTrans");
+ return RFAILED;
+ }
+ for(byteIdx = 0; byteIdx < rrcMsgSize; byteIdx++)
{
- dlCcchMsg[idx2] = \
- dlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf[idx2];
+ rrcMsgPdu[byteIdx] = \
+ dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf[byteIdx];
}
}
else
{
DU_LOG("\nDU_APP : RRC Container Size is invalid:%ld",\
- dlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
+ dlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
+ return RFAILED;
}
break;
}
-
+ case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
+ {
+ deliveryStaRpt = true;
+ break;
+ }
default:
DU_LOG("\nDU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
- dlRrcMsg->protocolIEs.list.array[idx]->id);
+ dlRrcMsg->protocolIEs.list.array[ieIdx]->id);
}
}
- for(idx=0; idx<duCb.numUe; idx++)
+ if(srbId == SRB1_LCID) //RRC connection setup
{
- if(gnbDuUeF1apId == duCb.ueCcchCtxt[idx].gnbDuUeF1apId)
+ for(ueIdx=0; ueIdx < duCb.numUe; ueIdx++)
{
- crnti = duCb.ueCcchCtxt[idx].crnti;
- cellId = duCb.ueCcchCtxt[idx].cellId;
- break;
+ if(gnbDuUeF1apId == duCb.ueCcchCtxt[ueIdx].gnbDuUeF1apId)
+ {
+ ueCcchCtxtFound = true;
+ crnti = duCb.ueCcchCtxt[ueIdx].crnti;
+ cellId = duCb.ueCcchCtxt[ueIdx].cellId;
+ break;
+ }
}
}
- if(srbId == SRB_ID_1) //RRC connection setup
+ if(ueCcchCtxtFound)
{
- ret = duBuildAndSendDlCcchInd(cellId, crnti, RRC_SETUP, dlCcchMsg, dlCcchMsgSize);
+ ret = duBuildAndSendDlCcchInd(&cellId, &crnti, RRC_SETUP, rrcMsgSize, rrcMsgPdu);
if(ret)
{
DU_LOG("\nDU_APP: Falied at duBuildAndSendDlCcchInd()");
{
if(duCb.actvCellLst[cellId-1]->numActvUes < MAX_NUM_UE)
{
- ret = duCreateUeCb(&duCb.ueCcchCtxt[idx], gnbCuUeF1apId);
+ ret = duCreateUeCb(&duCb.ueCcchCtxt[ueIdx], gnbCuUeF1apId);
if(ret)
{
- DU_LOG("\nDU_APP: Failed at duCreateUeCb for cellId [%d]", duCb.ueCcchCtxt[idx].cellId);
+ DU_LOG("\nDU_APP: Failed at duCreateUeCb for cellId [%d]", \
+ duCb.ueCcchCtxt[ueIdx].cellId);
ret = RFAILED;
}
}
ret = RFAILED;
}
}
- }
+ }
+ else
+ {
+ for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
+ {
+ for(ueIdx = 0 ; ueIdx < MAX_NUM_UE; ueIdx++)
+ {
+ if((gnbCuUeF1apId == duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId)
+ && (gnbDuUeF1apId == duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId))
+ {
+ ueFound = true;
+ ret = duBuildAndSendDlRrcMsgToRlc(duCb.actvCellLst[cellIdx]->cellId, \
+ duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, srbId, \
+ execDup, deliveryStaRpt, rrcMsgSize, rrcMsgPdu);
+ break;
+ }
+ }
+ if(ueFound)
+ break;
+ }
+ if(!ueFound)
+ ret = RFAILED;
+ }
return ret;
}
duCb.numUe++;
- ret = (BuildAndSendInitialRrcMsgTransfer(gnbDuUeF1apId, ulCcchIndInfo->crnti,
+ ret = (BuildAndSendInitialRrcMsgTransfer(gnbDuUeF1apId, ulCcchIndInfo->crnti, ulCcchIndInfo->ulCcchMsgLen,
ulCcchIndInfo->ulCcchMsg));
if(ret != ROK)
{
DU_LOG("\nDU_APP : BuildAndSendInitialRrcMsgTransfer failed");
}
- DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo->ulCcchMsg, strlen((const char*)ulCcchIndInfo->ulCcchMsg));
+ DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo->ulCcchMsg, ulCcchIndInfo->ulCcchMsgLen);
DU_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo, sizeof(UlCcchIndInfo));
return ret;
void fillInitDlBwp(InitialDlBwp *initDlBwp)
{
uint8_t idx = 0;
+ uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
+ uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
+
if(initDlBwp)
{
PDCCH_CTRL_RSRC_SET_ONE_ID;
memset(initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, 0,\
FREQ_DOM_RSRC_SIZE);
- initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc[idx] =\
- PDCCH_FREQ_DOM_RSRC;
+ coreset0EndPrb = CORESET0_END_PRB;
+ coreset1StartPrb = coreset0EndPrb +6;
+ coreset1NumPrb = CORESET1_NUM_PRB;
+ /* calculate the PRBs */
+ schAllocFreqDomRscType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
+ memcpy(initDlBwp->pdcchCfg.cRSetToAddModList[idx].freqDomainRsrc, freqDomainResource,
+ FREQ_DOM_RSRC_SIZE);
+
initDlBwp->pdcchCfg.cRSetToAddModList[idx].duration = \
PDCCH_CTRL_RSRC_SET_ONE_DURATION;
initDlBwp->pdcchCfg.cRSetToAddModList[idx].cceRegMappingType = \
{
if(lcCfgInfo)
{
- lcCfgInfo->lcId = SRB_ID_1;
+ lcCfgInfo->lcId = SRB1_LCID;
lcCfgInfo->drbQos = NULLP;
lcCfgInfo->snssai = NULLP;
lcCfgInfo->ulLcCfg = NULLP;
/* Filling AMBR for UL and DL */
ueCfg->maxAggrBitRate = NULLP;
/* Filling LC Context */
- ueCfg->numLcs = SRB_ID_1;
- if(ueCfg->numLcs < MAX_NUM_LOGICAL_CHANNELS)
+ ueCfg->numLcs = SRB1_LCID;
+ if(ueCfg->numLcs < MAX_NUM_LC)
{
for(idx = 0; idx < ueCfg->numLcs; idx++)
{
uint8_t idx;
ueCfg->cellId = cellId;
ueCfg->ueIdx = ueIdx;
- ueCfg->numLcs = SRB_ID_1;
+ ueCfg->numLcs = SRB1_LCID;
for(idx = 0; idx < ueCfg->numLcs; idx++)
{
ueCfg->rlcBearerCfg[idx].rbId = RB_ID_SRB;
ueCfg->rlcBearerCfg[idx].rbType = RB_TYPE_SRB;
- ueCfg->rlcBearerCfg[idx].lcId = SRB_ID_1;
+ ueCfg->rlcBearerCfg[idx].lcId = SRB1_LCID;
ueCfg->rlcBearerCfg[idx].lcType = LCH_DCCH;
ueCfg->rlcBearerCfg[idx].rlcMode = RLC_AM;
switch(ueCfg->rlcBearerCfg[idx].rlcMode)
GET_UE_IDX(ueCcchCtxt->crnti, ueIdx);
DU_LOG("\nDU_APP: Filling UeCb for ueIdx [%d]", ueIdx);
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId = ueCcchCtxt->gnbDuUeF1apId;
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId = gnbCuUeF1apId;
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState = UE_ACTIVE;
+ duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId = ueCcchCtxt->gnbDuUeF1apId;
+ duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId = gnbCuUeF1apId;
+ duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].ueState = UE_ACTIVE;
/* Filling Mac Ue Config */
- memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg, 0, sizeof(MacUeCfg));
+ memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg, 0, sizeof(MacUeCfg));
ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueIdx, ueCcchCtxt->crnti,\
- &duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg);
+ &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg);
if(ret)
DU_LOG("\nDU_APP: Failed to send UE create request to MAC");
/* Filling Rlc Ue Config */
- memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, 0, sizeof(RlcUeCfg));
+ memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg, 0, sizeof(RlcUeCfg));
ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueIdx, \
- &duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg);
+ &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg);
if(ret)
DU_LOG("\nDU_APP: Failed to send UE create request to RLC");
if(macUeCfg)
{
memset(macUeCfg, 0, sizeof(MacUeCfg));
- memcpy(macUeCfg, &duCb.actvCellLst[cellId - 1]->ueCb[ueIdx].macUeCfg, sizeof(MacUeCfg));
+ memcpy(macUeCfg, &duCb.actvCellLst[cellId - 1]->ueCb[ueIdx -1].macUeCfg, sizeof(MacUeCfg));
DU_LOG("\nDU_APP: Sending UE create request to MAC");
+
/* Processing one Ue at a time to MAC */
ret = (*packMacUeCreateReqOpts[pst.selector])(&pst, macUeCfg);
if(ret)
}
return ret;
}
+
/**********************************************************************
End of file
***********************************************************************/