#include "common_def.h"
#include "lrg.h"
#include "lrg.x"
+#include "ckw.h"
+#include "ckw.x"
+#include "kwu.h"
+#include "kwu.x"
+#include "lkw.h"
#include "lkw.x"
#include "legtp.h"
#include "du_app_mac_inf.h"
+#include "du_app_rlc_inf.h"
#include "du_cfg.h"
-#include "du_ue_mgr.h"
#include "du_utils.h"
#include<ProtocolIE-Field.h>
#include "F1AP-PDU.h"
+#include "du_mgr.h"
+#include "du_f1ap_msg_hdl.h"
+#include "du_ue_mgr.h"
#ifdef EGTP_TEST
U32 sduId = 0;
packDuMacUeCreateReq, /* Light weight-loose coupling */
};
-/******************************************************************
- *
- * @brief Send UE configuration to RLC
- *
- * @details
- *
- * Function : duSendUeCreateReqToRlc
- *
- * Functionality: Send UeCreateReqToRlc
- *
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-S16 duSendUeCreateReqToRlc()
+DuRlcUlUeCreateReq packRlcUlUeCreateReqOpts[] =
{
- U8 idx;
- Pst pst;
- CkwCfgInfo *ueCfg;
-
- DU_SET_ZERO(&ueCfg, sizeof(ueCfg));
- DU_SET_ZERO(&pst, sizeof(Pst));
-
- DU_ALLOC(ueCfg, sizeof(CkwCfgInfo));
-
-#ifdef EGTP_TEST
- ueCfg->ueId = UE_ID;
-#endif
- ueCfg->cellId = NR_CELL_ID;
- ueCfg->numEnt = 1;
-
- for(idx = 0; idx < ueCfg->numEnt; idx++)
- {
-#ifdef EGTP_TEST
- ueCfg->entCfg[idx].rbId = RB_ID;
- ueCfg->entCfg[idx].rbType = CM_LTE_DRB;
- ueCfg->entCfg[idx].lCh[0].lChId = LC_ID;
- ueCfg->entCfg[idx].lCh[0].type = CM_LTE_LCH_DTCH;
-#endif
- ueCfg->entCfg[idx].entMode = CM_LTE_MODE_UM;
- ueCfg->entCfg[idx].dir = CKW_CFG_DIR_BOTH;
- switch(ueCfg->entCfg[idx].entMode)
- {
- case CM_LTE_MODE_TM:
- {
- break;
- }
-
- case CM_LTE_MODE_UM:
- {
- ueCfg->entCfg[idx].m.umInfo.dl.snLen = 1; /* For 12 bit SN */
- ueCfg->entCfg[idx].m.umInfo.ul.snLen = 1; /* For 12 bit SN */
- ueCfg->entCfg[idx].m.umInfo.ul.reOrdTmr = 10; /* in msec */
- break;
- }
-
- case CM_LTE_MODE_AM:
- {
- break;
- }
-
- default:
- break;
- } /* End of switch(entMode) */
- } /* End of entity configuration for loop */
-
- /* Fill Pst */
- pst.selector = ODU_SELECTOR_LWLC;
- pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTKW;
- pst.dstInst = RLC_UL_INST;
- pst.dstProcId = DU_PROC;
- pst.srcProcId = DU_PROC;
- pst.region = duCb.init.region;
-
- /* Sending to RLC */
- packUeCreateReq(&pst, ueCfg);
+ packDuRlcUlUeCreateReq, /* Loose coupling */
+ RlcUlProcUeCreateReq, /* TIght coupling */
+ packDuRlcUlUeCreateReq, /* Light weight-loose coupling */
+};
- RETVALUE(ROK);
-} /* End of duSendUeCreateReqToRlc */
+DuDlRrcMsgToRlcFunc duSendDlRrcMsgToRlcOpts[] =
+{
+ packDlRrcMsgToRlc, /* Loose coupling */
+ RlcProcDlRrcMsgTransfer, /* Tight coupling */
+ packDlRrcMsgToRlc /* Light weight-loose coupling */
+};
/*******************************************************************
*
* RFAILED - failure
*
* ****************************************************************/
-S16 duHdlEgtpDlData(EgtpMsg *egtpMsg)
+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
- *
- *****************************************************************/
-
-PUBLIC S16 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;
DlCcchIndInfo *dlCcchIndInfo = NULLP;
Pst pst;
-
memset(&pst, 0, sizeof(Pst));
+
DU_LOG("\nDU APP : Building and Sending DL CCCH Ind to MAC");
DU_ALLOC_SHRABL_BUF(dlCcchIndInfo, sizeof(DlCcchIndInfo));
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;
*
*
*****************************************************************/
-void fillMacUeCfg(MacUeCfg *ueCfg)
+void fillMacUeCfg(uint16_t cellId, uint8_t ueIdx,\
+ uint16_t crnti, MacUeCfg *ueCfg)
{
uint8_t idx;
-
+ ueCfg->cellId = cellId;
+ ueCfg->ueIdx = ueIdx;
+ ueCfg->crnti = crnti;
/* Filling MacCellGroup Config */
fillMacCellGrpInfo(&ueCfg->macCellGrpCfg);
/* Filling PhyCellGroup Config */
/* 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++)
{
}
+/******************************************************************
+ *
+ * @brief Fills Rlc AM Information
+ *
+ * @details
+ *
+ * Function : fillAmInfo
+ *
+ * Functionality: Fills Rlc AM Information
+ *
+ *
+ *****************************************************************/
+void fillAmInfo(AmBearerCfg *amCfg)
+{
+ /* DL AM */
+ amCfg->dlAmCfg.snLenDl = AM_SIZE_12;
+ amCfg->dlAmCfg.pollRetxTmr = POLL_RETX_TMR_45MS;
+ amCfg->dlAmCfg.pollPdu = POLL_PDU_TMR_INFINITY;
+ amCfg->dlAmCfg.pollByte = POLL_BYTES_INFINITY;
+ amCfg->dlAmCfg.maxRetxTh = RETX_TH_8;
+
+ /* UL AM */
+ amCfg->ulAmCfg.snLenUl = AM_SIZE_12;
+ amCfg->ulAmCfg.reAssemTmr = RE_ASM_40MS;
+ amCfg->ulAmCfg.statProhTmr = PROH_35MS;
+
+}
+
+/******************************************************************
+ *
+ * @brief Fills RLC UM Bi Directional Information
+ *
+ * @details
+ *
+ * Function : fillUmBiDirInfo
+ *
+ * Functionality: Fills RLC UM Bi Directional Information
+ *
+ *
+ *****************************************************************/
+void fillUmBiDirInfo(UmBiDirBearerCfg *umBiDirCfg)
+{
+ /* UL UM BI DIR INFO */
+ umBiDirCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
+ umBiDirCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS;
+
+ /* DL UM BI DIR INFO */
+ umBiDirCfg->dlUmCfg.snLenDlUm = UM_SIZE_12;
+
+}
+
+/******************************************************************
+ *
+ * @brief Fills RLC UM Uni Directional UL Information
+ *
+ * @details
+ *
+ * Function : fillUmUniDirUlInfo
+ *
+ * Functionality: Fills RLC UM Uni Directional Info
+ *
+ *
+ *****************************************************************/
+void fillUmUniDirUlInfo(UmUniDirUlBearerCfg *umUniDirUlCfg)
+{
+ umUniDirUlCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
+ umUniDirUlCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS;
+}
+
+/******************************************************************
+ *
+ * @brief Fills RLC UM Uni Directional DL Information
+ *
+ * @details
+ *
+ * Function : fillUmUniDirDlInfo
+ *
+ * Functionality: Fills RLC UM Uni Directional DL Info
+ *
+ *
+ *****************************************************************/
+void fillUmUniDirDlInfo(UmUniDirDlBearerCfg *umUniDirDlCfg)
+{
+ umUniDirDlCfg->dlUmCfg.snLenDlUm = UM_SIZE_12;
+}
+
+/******************************************************************
+ *
+ * @brief Fills RlcBearerCfg structure
+ *
+ * @details
+ *
+ * Function : fillRlcBearerCfg
+ *
+ * Functionality: Fills Rlc Bearer Cfg
+ *
+ *
+ *****************************************************************/
+void fillRlcBearerCfg(uint16_t cellId, uint8_t ueIdx, RlcUeCfg *ueCfg)
+{
+ uint8_t idx;
+ ueCfg->cellId = cellId;
+ ueCfg->ueIdx = ueIdx;
+ 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 = SRB1_LCID;
+ ueCfg->rlcBearerCfg[idx].lcType = LCH_DCCH;
+ ueCfg->rlcBearerCfg[idx].rlcMode = RLC_AM;
+ switch(ueCfg->rlcBearerCfg[idx].rlcMode)
+ {
+ case RLC_AM:
+ memset(&ueCfg->rlcBearerCfg[idx].u.amCfg, 0, sizeof(AmBearerCfg));
+ fillAmInfo(&ueCfg->rlcBearerCfg[idx].u.amCfg);
+ break;
+ case RLC_UM_BI_DIRECTIONAL:
+ memset(&ueCfg->rlcBearerCfg[idx].u.umBiDirCfg, 0, sizeof(UmBiDirBearerCfg));
+ fillUmBiDirInfo(&ueCfg->rlcBearerCfg[idx].u.umBiDirCfg);
+ break;
+ case RLC_UM_UNI_DIRECTIONAL_UL:
+ memset(&ueCfg->rlcBearerCfg[idx].u.umUniDirUlCfg, 0, sizeof(UmUniDirUlBearerCfg));
+ fillUmUniDirUlInfo(&ueCfg->rlcBearerCfg[idx].u.umUniDirUlCfg);
+ break;
+ case RLC_UM_UNI_DIRECTIONAL_DL:
+ memset(&ueCfg->rlcBearerCfg[idx].u.umUniDirDlCfg, 0, sizeof(UmUniDirDlBearerCfg));
+ fillUmUniDirDlInfo(&ueCfg->rlcBearerCfg[idx].u.umUniDirDlCfg);
+ break;
+ default :
+ DU_LOG("\nDU_APP: Rlc Mode invalid %d", ueCfg->rlcBearerCfg[idx].rlcMode);
+ break;
+ }
+ }
+}
+
/******************************************************************
*
* @brief creates UE context
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));
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.cellId = ueCcchCtxt->cellId;
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.ueIdx = ueIdx;
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.crnti = ueCcchCtxt->crnti;
- fillMacUeCfg(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg);
+ memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].macUeCfg, 0, sizeof(MacUeCfg));
+ ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueIdx, ueCcchCtxt->crnti,\
+ &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-1].rlcUeCfg, 0, sizeof(RlcUeCfg));
+ ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueIdx, \
+ &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].rlcUeCfg);
+ if(ret)
+ DU_LOG("\nDU_APP: Failed to send UE create request to RLC");
+
duCb.actvCellLst[cellIdx]->numActvUes++;
memset(ueCcchCtxt, 0, sizeof(UeCcchCtxt));
-
- /* Send Ue Create Request to MAC */
- ret = duBuildAndSendUeCreateReqToMac(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.cellId, ueIdx);
- if(ret)
- DU_LOG("\nDU_APP: Failed to send UE create request to MAC");
}
}
-
return ret;
}
*
* ****************************************************************/
-uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx)
+uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\
+ uint16_t crnti, MacUeCfg *duMacUeCfg)
{
uint8_t ret = ROK;
MacUeCfg *macUeCfg = NULLP;
Pst pst;
-
memset(&pst, 0, sizeof(Pst));
+ fillMacUeCfg(cellId, ueIdx, crnti, duMacUeCfg);
+
/* Fill Pst */
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_CREATE_REQ);
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)
}
else
{
- DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReq()");
+ DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToMac()");
ret = RFAILED;
}
return ret;
*
* @details
*
- * Function : duHandleMacUeCreateRsp
+ * Function : DuHandleMacUeCreateRsp
*
* Functionality: Handle UE create response from MAC
*
- * @params[in]
+ * @params[in] Pointer to MacUeCfgRsp and Pst
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t duHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp)
+uint8_t DuHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp)
{
if(cfgRsp->result == MAC_DU_APP_RSP_OK)
{
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Processes UE create Req to RLC UL
+ *
+ * @details
+ *
+ * Function : duBuildAndSendUeCreateReqToRlc
+ *
+ * Functionality:
+ * Processes UE create Req to RLC UL
+ *
+ * @params[in] cellId,
+ * ueIdx,
+ * Pointer to RlcUeCfg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx, RlcUeCfg *duRlcUeCfg)
+{
+ uint8_t ret = ROK;
+ RlcUeCfg *rlcUeCfg = NULLP;
+ Pst pst;
+ memset(&pst, 0, sizeof(Pst));
+
+ fillRlcBearerCfg(cellId, ueIdx, duRlcUeCfg);
+ FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UL_UE_CREATE_REQ);
+
+ /* Copying ueCfg to a sharable buffer */
+ DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
+ if(rlcUeCfg)
+ {
+ memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
+ memcpy(rlcUeCfg, duRlcUeCfg, sizeof(RlcUeCfg));
+ /* Processing one Ue at a time to RLC */
+ DU_LOG("\nDU_APP: Sending UE create request to RLC UL");
+ ret = (*packRlcUlUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg);
+ if(ret)
+ {
+ DU_LOG("\nDU_APP : Failure in sending Ue Create Req to RLC");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToRlc()");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+
+
+/*******************************************************************
+ *
+ * @brief Processes UE create Rsp received from RLC UL
+ *
+ * @details
+ *
+ * Function : DuProcRlcUlUeCfgRsp
+ *
+ * Functionality:
+ * Processes UE create Rsp received from RLC UL
+ *
+ * @params[in] Post structure
+ * Pointer to RlcCfgCfm
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t DuProcRlcUlUeCreateRsp(Pst *pst, RlcUeCfgRsp *cfgRsp)
+{
+ uint8_t ret = ROK;
+
+ if(cfgRsp)
+ {
+ if(cfgRsp->result == RLC_DU_APP_RSP_OK)
+ {
+ DU_LOG("\nDU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
+ }
+ else
+ {
+ DU_LOG("\nDU_APP: RLC UE Create Response : FAILED [UE IDX:%d, REASON :%d]",\
+ cfgRsp->ueIdx, cfgRsp->reason);
+ ret = RFAILED;
+ }
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
+ }
+ else
+ {
+ DU_LOG("\nDU_APP: Received RLC Ue Create Response is NULL");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
/**********************************************************************
End of file
***********************************************************************/
Code Review / o-du / l2.git / blobdiff