+
+ return (ret);
+}
+
+/*******************************************************************
+ *
+ * @brief Sends UL user data over to EGTP
+ *
+ * @details
+ *
+ * Function : duSendEgtpDatInd
+ *
+ * Functionality: Sends UL user data over to EGTP
+ *
+ * @params[in] UL data buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t duSendEgtpDatInd(Buffer *mBuf)
+{
+ EgtpMsg egtpMsg;
+
+ /* Fill EGTP header */
+ egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU;
+ egtpMsg.msgHdr.nPdu.pres = FALSE;
+ egtpMsg.msgHdr.seqNum.pres = FALSE;
+ egtpMsg.msgHdr.extHdr.udpPort.pres = FALSE;
+ egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE;
+ egtpMsg.msgHdr.teId = 1;
+ egtpMsg.msg = mBuf;
+
+ egtpHdlDatInd(egtpMsg);
+
+ return ROK;
+
+}
+
+/**************************************************************************
+ * @brief Function to send configs to SCH
+ *
+ * @details
+ *
+ * Function : duSendSchCfg
+ *
+ * Functionality:
+ * Sends general config to Scheduler via MAC layer
+ *
+ * @param[in] void
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t duSendSchCfg()
+{
+ RgMngmt rgMngmt;
+ RgSchInstCfg *cfg = NULLP;
+ Pst pst;
+
+ DU_SET_ZERO(&pst, sizeof(Pst));
+ DU_SET_ZERO(&rgMngmt, sizeof(RgMngmt));
+
+ cfg = &(rgMngmt.t.cfg.s.schInstCfg);
+
+ /* Filling of Instance Id */
+ cfg->instId = DEFAULT_CELLS + 1;
+ /* Filling of Gen config */
+ cfg->genCfg.mem.region = MAC_MEM_REGION;
+ cfg->genCfg.mem.pool = MAC_POOL;
+ cfg->genCfg.tmrRes = 10;
+
+#ifdef LTE_ADV
+ cfg->genCfg.forceCntrlSrbBoOnPCel = FALSE;
+ cfg->genCfg.isSCellActDeactAlgoEnable = TRUE;
+#endif/*LTE_ADV*/
+ cfg->genCfg.startCellId = 1;
+ cfg->genCfg.lmPst.dstProcId = DU_PROC;
+ cfg->genCfg.lmPst.srcProcId = DU_PROC;
+ cfg->genCfg.lmPst.dstEnt = ENTDUAPP;
+ cfg->genCfg.lmPst.dstInst = DU_INST;
+ cfg->genCfg.lmPst.srcEnt = ENTMAC;
+ cfg->genCfg.lmPst.srcInst = DEFAULT_CELLS + 1;
+ cfg->genCfg.lmPst.prior = PRIOR0;
+ cfg->genCfg.lmPst.route = RTESPEC;
+ cfg->genCfg.lmPst.region = MAC_MEM_REGION;
+ cfg->genCfg.lmPst.pool = MAC_POOL;
+ cfg->genCfg.lmPst.selector = ODU_SELECTOR_LC;
+
+ /* Fill Header */
+ rgMngmt.hdr.msgType = TCFG;
+ rgMngmt.hdr.entId.ent = ENTMAC;
+ rgMngmt.hdr.entId.inst = DU_INST;
+ rgMngmt.hdr.elmId.elmnt = STSCHINST;
+ rgMngmt.hdr.response.mem.region = MAC_MEM_REGION;
+ rgMngmt.hdr.response.mem.pool = MAC_POOL;
+
+ /* Fill Pst */
+ pst.selector = ODU_SELECTOR_LC;
+ pst.srcEnt = ENTDUAPP;
+ pst.dstEnt = ENTMAC;
+ pst.dstProcId = DU_PROC;
+ pst.srcProcId = DU_PROC;
+ pst.srcInst = DU_INST;
+ pst.dstInst = 0;
+ pst.region = duCb.init.region;
+ pst.event = (Event) EVTMACSCHGENCFGREQ;
+
+ DU_LOG("\nDEBUG --> DU_APP : MAC Sch Cfg sent");
+
+ /* Send the request to MAC */
+ cmPkLrgSchCfgReq(&pst, &rgMngmt);
+
+ return ROK;
+}
+
+
+/**************************************************************************
+ * @brief Function to configure SCTP params and
+ * responsible for F1 and E2 interfaces
+ *
+ * @details
+ *
+ * Function : duLayerConfigComplete
+ *
+ * Functionality:
+ * Configures SCTP Params and responsible for handling
+ * F1 and E2 interface.
+ *
+ * @param[in] void
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t duLayerConfigComplete()
+{
+ uint8_t ret = ROK;
+
+ DU_LOG("\nINFO --> DU_APP : Configuring all Layer is complete");
+
+ if((ret = duSctpCfgReq(duCfgParam.sctpParams)) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed configuring Sctp Params");
+ ret = RFAILED;
+ }
+ if((ret = duSctpAssocReq(F1_INTERFACE)) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq F1");
+ ret = RFAILED;
+ }
+ if((ret = duSctpAssocReq(E2_INTERFACE)) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq E2");
+ ret = RFAILED;
+ }
+
+ return (ret);
+}
+
+/**************************************************************************
+ * @brief Function to handle SCH Config Confirm from MAC
+ *
+ * @details
+ *
+ * Function : duHdlSchCfgComplete
+ *
+ * Functionality:
+ * Handles Scheduler Gen Config Confirm from MAC
+ *
+ * @param[in] Pst *pst, Post structure of the primitive.
+ * @param[in] RgMngmt *cfm, Unpacked primitive info received from MAC
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm)
+{
+ if (cfm->cfm.status == LCM_PRIM_OK)
+ {
+ switch (cfm->hdr.elmId.elmnt)
+ {
+ case STSCHINST:
+ {
+ DU_LOG("\nDEBUG --> DU_APP : Received SCH CFG CFM at DU APP");
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ duLayerConfigComplete();
+ duBuildEgtpCfgReq();
+ return ROK;
+}
+
+/**************************************************************************
+ * @brief Function to fill and send MacCellconfig
+ *
+ * @details
+ *
+ * Function : duBuildAndSendMacCellCfg
+ *
+ * Functionality:
+ * Initiates MAC Configs towards MAC
+ *
+ * @param[in]cell id
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t duBuildAndSendMacCellCfg(uint16_t cellId)
+{
+ Pst pst;
+ MacCellCfg *duMacCellCfg = NULLP;
+
+ DU_ALLOC_SHRABL_BUF(duMacCellCfg, sizeof(MacCellCfg));
+ if(duMacCellCfg == NULLP)
+ {
+ return RFAILED;
+ }
+
+ /* store the address in the duCellCb so that we can free on confirm msg */
+ duCb.actvCellLst[cellId-1]->duMacCellCfg = duMacCellCfg;
+
+ /* copy the mac config structure from duCfgParams */
+ memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg));
+
+ /* Fill Pst */
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_CONFIG_REQ);
+
+ /* Send MAC cell config to MAC */
+ return (*packMacCellCfgOpts[pst.selector])(&pst, duMacCellCfg);
+}
+
+/**************************************************************************
+ * @brief Function to Handle MAC cell config confirm
+ *
+ * @details
+ *
+ * Function : duHandleMacCellCfgCfm
+ *
+ * Functionality:
+ * Initiates general Configs towards MAC
+ *
+ * @param[in] void
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t duHandleMacCellCfgCfm(Pst *pst, MacCellCfgCfm *macCellCfgCfm)
+{
+ uint8_t actvCellIdx = 0;
+ uint8_t ret = ROK;
+
+ for(actvCellIdx = 0; actvCellIdx < MAX_NUM_CELL; actvCellIdx++)
+ {
+ if(macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId)
+ {
+ duCb.actvCellLst[actvCellIdx]->duMacCellCfg = NULLP;
+ }
+ }
+ if(macCellCfgCfm->rsp == ROK)
+ {
+ /* Build and send GNB-DU config update */
+ ret = BuildAndSendDUConfigUpdate(SERV_CELL_TO_MODIFY);
+
+ /* Build and Send Cell Start Req to MAC */
+ ret = duBuildAndSendMacCellStart();
+ }
+ else
+ {
+ /* TODO : Action to be taken if cell configuration fails.
+ * Should CU be informed? */
+
+ DU_LOG("\nERROR --> DU_APP : Mac cell cfg failed");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds and sends cell start request to MAC
+ *
+ * @details
+ *
+ * Function : duBuildAndSendMacCellStart
+ *
+ * Functionality:
+ * Builds and sends cell start request to MAC
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t duBuildAndSendMacCellStart()
+{
+ Pst pst;
+ OduCellId *cellId = NULL;
+
+ DU_LOG("\nINFO --> DU APP : Building and Sending cell start request to MAC");
+
+ /* Send Cell Start Request to MAC */
+ DU_ALLOC_SHRABL_BUF(cellId, sizeof(OduCellId));
+ if(!cellId)
+ {
+ DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell start request");
+ return RFAILED;
+ }
+
+ for(uint8_t id = 0; id < duCb.numActvCells; id++)
+ {
+ if(duCb.actvCellLst[id])
+ {
+ cellId->cellId = duCb.actvCellLst[id]->cellId;
+
+ /* Fill Pst */
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START);
+
+ return (*packMacCellStartOpts[pst.selector])(&pst, cellId);
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Builds and sends cell stop request to MAC
+ *
+ * @details
+ *
+ * Function : duBuildAndSendMacCellStop
+ *
+ * Functionality:
+ * Builds and sends cell stop request to MAC
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t duBuildAndSendMacCellStop(uint16_t cellId)
+{
+ Pst pst;
+ uint16_t cellIdx=0;
+ OduCellId *oduCellId = NULL;
+
+ DU_LOG("\nINFO --> DU APP : Building and Sending cell stop request to MAC");
+
+ GET_CELL_IDX(cellId, cellIdx);
+ if(duCb.actvCellLst[cellIdx] != NULLP)
+ {
+ /* Send Cell Stop Request to MAC */
+ DU_ALLOC_SHRABL_BUF(oduCellId, sizeof(OduCellId));
+ if(!oduCellId)
+ {
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendMacCellStop(): Memory allocation failed ");
+ return RFAILED;
+ }
+ memset(oduCellId, 0, sizeof(OduCellId));
+ oduCellId->cellId = duCb.actvCellLst[cellIdx]->cellId;
+
+ /* Fill Pst */
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP);
+
+ return (*packMacCellStopOpts[pst.selector])(&pst, oduCellId);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendMacCellStop(): cellId[%d] doesnot exists", cellId);
+ return RFAILED;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Handles stop indication from MAC
+ *
+ * @details
+ *
+ * Function : duHandleStopInd
+ *
+ * Functionality:
+ * Handles stop indication from MAC
+ *
+ * @params[in] Post structure pointer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t duHandleStopInd(Pst *pst, OduCellId *cellId)
+{
+ DuCellCb *cellCb = NULLP;
+
+ if(cellId->cellId <=0 || cellId->cellId > MAX_NUM_CELL)
+ {
+ DU_LOG("\nERROR --> DU APP : Invalid Cell Id %d in duHandleStopInd()", cellId->cellId);
+ }
+
+ if(duGetCellCb(cellId->cellId, &cellCb) != ROK)
+ return RFAILED;
+
+ if((cellCb->cellStatus == ACTIVATED) || (cellCb->cellStatus == DELETION_IN_PROGRESS))
+ {
+ DU_LOG("\nINFO --> DU APP : 5G-NR Cell %d is DOWN", cellId->cellId);
+ if(sendCellDeleteReqToMac(cellId->cellId) == RFAILED)
+ {
+ DU_LOG("\nERROR --> DU APP : duHandleStopInd(): Failed to send Cell delete req to MAC for\
+ cellId[%d]", cellId->cellId);
+ return RFAILED;
+ }
+
+
+#ifdef O1_ENABLE
+ DU_LOG("\nINFO --> DU APP : Raise cell down alarm for cell id=%d", cellId->cellId);
+ raiseCellAlrm(CELL_DOWN_ALARM_ID, cellId->cellId);
+ setCellOpState(cellId->cellId, DISABLED, INACTIVE);
+#endif
+ }
+
+ if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC))
+ DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, cellId, sizeof(OduCellId));
+
+ cellCb->cellStatus = CELL_OUT_OF_SERVICE; //TODO: cell status must be set to OOS after all UE and cell cleanup which is not
+ //supported now
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Handles slot indication from MAC
+ *
+ * @details
+ *
+ * Function : duHandleUlCcchInd
+ *
+ * Functionality:
+ * Handles UL CCCH indication from MAC
+ *
+ * @params[in] Post structure pointer
+ * UL CCCH Ind pointer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t duHandleUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo)
+{
+
+ DU_LOG("\nINFO --> DU APP : UL CCCH Indication received");
+
+ return (duProcUlCcchInd(ulCcchIndInfo));
+}
+
+/*******************************************************************
+ *
+ * @brief Process UL RRC Message from RLC
+ *
+ * @details
+ *
+ * Function : DuProcRlcUlRrcMsgTrans
+ *
+ * Functionality: Process UL RRC Message from RLC
+ *
+ * @params[in] Post structure
+ * UL RRC Message Info
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t DuProcRlcUlRrcMsgTrans(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo)
+{
+ DuCellCb *cellCb = NULLP;
+ DuUeCb ueCb ={0};
+
+ if(duGetCellCb(ulRrcMsgInfo->cellId, &cellCb) != ROK)
+ return RFAILED;
+ if(ulRrcMsgInfo->ueIdx > 0)
+ {
+ ueCb = cellCb->ueCb[ulRrcMsgInfo->ueIdx -1];
+
+
+ BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, \
+ ulRrcMsgInfo->rrcMsg);
+
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo->rrcMsg, ulRrcMsgInfo->msgLen);
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
+ }
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Process RRC delivery report from RLC
+*
+* @details
+*
+* Function : DuProcRlcRrcDeliveryReport
+*
+* Functionality: Process RRC delivery Message from RLC
+*
+* @params[in] Post structure
+* UL RRC Message Info
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t DuProcRlcRrcDeliveryReport(Pst *pst, RrcDeliveryReport *rrcDeliveryReport)
+{
+ DuCellCb *cellCb = NULLP;
+ DuUeCb ueCb;
+ uint8_t ret = RFAILED;
+
+ if(duGetCellCb(rrcDeliveryReport->cellId, &cellCb) != ROK)
+ return RFAILED;
+
+ ueCb = cellCb->ueCb[rrcDeliveryReport->ueIdx -1];
+ ret = BuildAndSendRrcDeliveryReport(ueCb.gnbCuUeF1apId, ueCb.gnbDuUeF1apId,rrcDeliveryReport);
+
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, rrcDeliveryReport, sizeof(RrcDeliveryReport));
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Process UL user data from RLC
+ *
+ * @details
+ *
+ * Function : DuProcRlcUlUserDataTrans
+ *
+ * Functionality: Process UL user data from RLC
+ *
+ * @params[in] Post structure
+ * UL user data
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t DuProcRlcUlUserDataTrans(Pst *pst, RlcUlUserDatInfo *ulUserData)
+{
+ uint8_t rbIdx;
+ EgtpMsg egtpMsg;
+ Buffer *mBuf;
+
+ DU_LOG("\nDEBUG --> DU APP : Received UL user data");
+
+ /* Fill EGTP header */
+ egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU;
+ egtpMsg.msgHdr.nPdu.pres = FALSE;
+ egtpMsg.msgHdr.seqNum.pres = FALSE;
+ egtpMsg.msgHdr.extHdr.udpPort.pres = FALSE;
+ egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE;
+
+ /* Fetch EGTP tunnel info */
+ for(rbIdx = 0; rbIdx < duCb.numDrb; rbIdx++)
+ {
+ if((duCb.upTnlCfg[rbIdx] != NULLP) && (duCb.upTnlCfg[rbIdx]->drbId == ulUserData->rbId))
+ {
+ if(duCb.upTnlCfg[rbIdx]->tnlCfg1)
+ {
+ egtpMsg.msgHdr.teId = duCb.upTnlCfg[rbIdx]->tnlCfg1->teId; /*As we are supporting only 1 tunnel per DRB*/
+ break;
+ }
+ }
+ }
+
+ if (ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) != ROK)
+ {
+ DU_LOG("\nERROR --> DU APP : Failed to allocated buffer memory in DuProcRlcUlUserDataTrans");
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData->userData, ulUserData->msgLen);
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData, sizeof(RlcUlUserDatInfo));
+ return RFAILED;
+ }
+ oduCpyFixBufToMsg(ulUserData->userData, mBuf, ulUserData->msgLen);
+ ODU_PRINT_MSG(mBuf, 0, 0);
+ egtpMsg.msg = mBuf;
+ egtpHdlDatInd(egtpMsg);
+
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData->userData, ulUserData->msgLen);
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData, sizeof(RlcUlUserDatInfo));
+ return ROK;