# macro for output file name and makefile name
#
-PLTFRM_FLAGS= -UMSPD -DODU -DINTEL_FAPI #-DODU_MEMORY_DEBUG_LOG #-DODU_SLOT_IND_DEBUG_LOG -DEGTP_TEST
+PLTFRM_FLAGS= -UMSPD -DODU -DINTEL_FAPI #-DCALL_FLOW_DEBUG_LOG #-DODU_MEMORY_DEBUG_LOG #-DODU_SLOT_IND_DEBUG_LOG -DEGTP_TEST
ifeq ($(MODE),TDD)
PLTFRM_FLAGS += -DNR_TDD
return ROK;\r
}\r
\r
+/**************************************************************************\r
+* @brief function prints src, dest, msg info about all the msgs received \r
+*\r
+* @details\r
+*\r
+* Function : callFlowlwrMacActvTsk \r
+*\r
+* Functionality:\r
+* function prints src, dest, msg info about all the msgs received\r
+*\r
+* @param[in] Pst *pst\r
+*\r
+* @return void \r
+***************************************************************************/\r
+\r
+void callFlowlwrMacActvTsk(Pst *pst)\r
+{\r
+ char sourceTask[50];\r
+ char destTask[50]="ENTLWRMAC";\r
+ char message[100];\r
+\r
+ switch(pst->srcEnt)\r
+ {\r
+ case ENTLWRMAC:\r
+ {\r
+ strcpy(sourceTask,"ENTLWRMAC");\r
+ switch(pst->event)\r
+ {\r
+#ifdef INTEL_WLS_MEM\r
+ case EVT_START_WLS_RCVR:\r
+ {\r
+ strcpy(message,"EVT_START_WLS_RCVR");\r
+ break;\r
+ }\r
+#endif\r
+ default:\r
+ {\r
+ strcpy(message,"Invalid Event");\r
+ break;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+\r
+#ifndef INTEL_WLS_MEM\r
+ case ENTPHYSTUB:\r
+ {\r
+ strcpy(sourceTask,"PHY");\r
+ switch(pst->event)\r
+ {\r
+ case EVT_PHY_STUB_SLOT_IND:\r
+ {\r
+ strcpy(message,"EVT_PHY_STUB_SLOT_IND");\r
+ break;\r
+ }\r
+\r
+ case EVT_PHY_STUB_STOP_IND:\r
+ {\r
+ strcpy(message,"EVT_PHY_STUB_STOP_IND");\r
+ break;\r
+ }\r
+ default:\r
+ {\r
+ strcpy(message,"Invalid Event");\r
+ break;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+#endif\r
+\r
+ default:\r
+ {\r
+ strcpy(sourceTask,"Invalid Source Entity Id");\r
+ }\r
+ }\r
+ DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);\r
+}\r
/**************************************************************************\r
* @brief Task Activation callback function. \r
*\r
{\r
uint8_t ret = ROK;\r
\r
+#ifdef CALL_FLOW_DEBUG_LOG\r
+ callFlowlwrMacActvTsk(pst);\r
+#endif\r
+ \r
switch(pst->srcEnt)\r
{\r
case ENTLWRMAC:\r
* ****************************************************************/
uint8_t lwr_mac_procInvalidEvt(void *msg)
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : INVALID_EVENT\n");
+#endif
DU_LOG("\nERROR --> LWR_MAC: Error Indication Event[%d] received in state [%d]", lwrMacCb.event, lwrMacCb.phyState);
return ROK;
}
uint8_t lwr_mac_procParamReqEvt(void *msg)
{
#ifdef INTEL_FAPI
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : PARAM_REQ\n");
+#endif
+
/* startGuardTimer(); */
fapi_param_req_t *paramReq = NULL;
fapi_msg_header_t *msgHeader;
uint8_t lwr_mac_procConfigReqEvt(void *msg)
{
#ifdef INTEL_FAPI
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : CONFIG_REQ\n");
+#endif
#ifdef NR_TDD
uint8_t slotIdx = 0;
uint8_t symbolIdx =0;
uint8_t lwr_mac_procStartReqEvt(void *msg)
{
#ifdef INTEL_FAPI
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : START_REQ\n");
+#endif
fapi_msg_header_t *msgHeader;
fapi_start_req_t *startReq;
fapi_vendor_msg_t *vendorMsg;
uint8_t lwr_mac_procStopReqEvt(SlotIndInfo slotInfo, p_fapi_api_queue_elem_t prevElem)
{
#ifdef INTEL_FAPI
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : STOP_REQ\n");
+#endif
+
fapi_stop_req_t *stopReq;
fapi_vendor_msg_t *vendorMsg;
p_fapi_api_queue_elem_t stopReqElem;
* ****************************************************************/
uint16_t fillDlTtiReq(SlotIndInfo currTimingInfo)
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : DL_TTI_REQUEST\n");
+#endif
+
#ifdef INTEL_FAPI
uint8_t idx =0;
uint8_t nPdu = 0;
uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo, p_fapi_api_queue_elem_t prevElem)
{
#ifdef INTEL_FAPI
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : TX_DATA_REQ\n");
+#endif
+
uint8_t nPdu = 0;
uint16_t cellIdx;
uint16_t pduIndex = 0;
******************************************************************/
uint16_t fillUlTtiReq(SlotIndInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem)
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : UL_TTI_REQUEST\n");
+#endif
+
#ifdef INTEL_FAPI
uint16_t cellIdx =0;
uint8_t pduIdx = -1;
******************************************************************/
void fillUlDciPdu(fapi_dl_dci_t *ulDciPtr, DciInfo *schDciInfo)
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : UL_DCI_REQUEST\n");
+#endif
if(ulDciPtr != NULLP)
{
uint8_t numBytes =0;
}
#endif /* FAPI */
+/*******************************************************************
+ * @brief Function prints src, dest, msg infor about all the msgs that
+ received.
+ *
+ * @details
+ *
+ * Function :callFlowFromPhyToLwrMac
+ *
+ * Function call Flow From Phy To LwrMac
+ *
+ * @param[in] Pst *pst, Post structure of the primitive.
+ *
+ * @return void
+ * ****************************************************************/
+void callFlowFromPhyToLwrMac(uint16_t msgId)
+{
+ char message[100];
+ switch(msgId)
+ {
+#ifdef INTEL_TIMER_MODE
+ case FAPI_VENDOR_EXT_UL_IQ_SAMPLES:
+ strcpy(message,"FAPI_VENDOR_EXT_UL_IQ_SAMPLES");
+ break;
+#endif
+ case FAPI_PARAM_RESPONSE:
+ strcpy(message,"FAPI_PARAM_RESPONSE");
+ break;
+ case FAPI_CONFIG_RESPONSE:
+ strcpy(message,"FAPI_CONFIG_RESPONSE");
+ break;
+ case FAPI_SLOT_INDICATION:
+ strcpy(message,"FAPI_SLOT_INDICATION");
+ break;
+ case FAPI_ERROR_INDICATION:
+ strcpy(message,"FAPI_ERROR_INDICATION");
+ break;
+ case FAPI_RX_DATA_INDICATION:
+ strcpy(message,"FAPI_RX_DATA_INDICATION");
+ break;
+ case FAPI_CRC_INDICATION:
+ strcpy(message,"FAPI_CRC_INDICATION");
+ break;
+ case FAPI_UCI_INDICATION:
+ strcpy(message,"FAPI_UCI_INDICATION");
+ break;
+ case FAPI_SRS_INDICATION:
+ strcpy(message,"FAPI_SRS_INDICATION");
+ break;
+ case FAPI_RACH_INDICATION:
+ strcpy(message,"FAPI_RACH_INDICATION");
+ break;
+ case FAPI_STOP_INDICATION:
+ strcpy(message,"FAPI_STOP_INDICATION");
+ break;
+ }
+ DU_LOG("\nCall Flow: PHY -> ENTLWRMAC : %s\n",message);
+}
/*******************************************************************
*
* @brief Processes message from PHY
fapi_msg_t *header = NULLP;
header = (fapi_msg_t *)msg;
+#ifdef CALL_FLOW_DEBUG_LOG
+ callFlowFromPhyToLwrMac(header->msg_id);
+#endif
switch(header->msg_id)
{
#ifdef INTEL_TIMER_MODE
uint8_t ret = ROK;
#ifdef INTEL_FAPI
uint16_t msgLen =0;
+ char message[100];
p_fapi_api_queue_elem_t currMsg = NULLP;
+#ifdef CALL_FLOW_DEBUG_LOG
+ currMsg = (p_fapi_api_queue_elem_t)msg;
+ while(currMsg)
+ {
+ switch(currMsg->msg_type)
+ {
+ case FAPI_PARAM_REQUEST:
+ strcpy(message, "FAPI_PARAM_REQUEST");
+ break;
+ case FAPI_CONFIG_REQUEST:
+ strcpy(message, "FAPI_CONFIG_REQUEST");
+ break;
+ case FAPI_START_REQUEST:
+ strcpy(message, "FAPI_START_REQUEST");
+ break;
+ case FAPI_DL_TTI_REQUEST:
+ strcpy(message, "FAPI_DL_TTI_REQUEST");
+ break;
+ case FAPI_TX_DATA_REQUEST:
+ strcpy(message, "FAPI_TX_DATA_REQUEST");
+ break;
+ case FAPI_UL_TTI_REQUEST:
+ strcpy(message, "FAPI_UL_TTI_REQUEST");
+ break;
+ case FAPI_STOP_REQUEST:
+ strcpy(message, "FAPI_STOP_REQUEST");
+ break;
+ case FAPI_UL_DCI_REQUEST:
+ strcpy(message, "FAPI_UL_DCI_REQUEST");
+ break;
+ default:
+ strcpy(message, "INVALID_MSG");
+ break;
+ }
+ DU_LOG("\nCall Flow: ENTLWRMAC -> PHY : %s\n",message);
+ currMsg = currMsg->p_next;
+ }
+#endif
+
+
#ifdef INTEL_WLS_MEM
void * wlsHdlr = NULLP;
{
uint16_t *cellId = NULLP;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_SCH_CELL_CFG_CFM\n");
+#endif
+
if(schCellCfgCfm->rsp == RSP_OK)
{
cellId = &schCellCfgCfm->cellId;
uint8_t ret = ROK;
uint16_t cellIdx=0;
CellDeleteStatus status;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n");
+#endif
if(schCellDelRsp)
{
}
}
+/**
+* @brief Function prints src, dest, msg infor about all the msgs that received.
+*
+* @details
+*
+* Function : callFlowRgActvTsk
+*
+* Function prints src, dest, msg infor about all the msgs that received
+*
+* @param[in] Pst *pst, Post structure of the primitive.
+*
+* @return void
+**/
+
+void callFlowRgActvTsk(Pst *pst)
+{
+ char sourceTask[50];
+ char destTask[50]="ENTMAC";
+ char message[100];
+
+ switch(pst->srcEnt)
+ {
+ case ENTDUAPP:
+ {
+ strcpy(sourceTask,"ENTDUAPP");
+ switch(pst->event)
+ {
+#ifdef LCRGMILRG
+ case EVTLRGCFGREQ:
+ strcpy(message,"EVTLRGCFGREQ");
+ break;
+ case EVTMACSCHGENCFGREQ:
+ strcpy(message,"EVTMACSCHGENCFGREQ");
+ break;
+ case EVTLRGCNTRLREQ:
+ strcpy(message,"EVTLRGCNTRLREQ");
+ break;
+ case EVTLRGSSTAREQ:
+ strcpy(message,"EVTLRGSSTAREQ");
+ break;
+ case EVTLRGSTSREQ:
+ strcpy(message,"EVTLRGSTSREQ");
+ break;
+#endif /* LCRGMILRG */
+ case EVENT_MAC_CELL_CONFIG_REQ:
+ strcpy(message,"EVENT_MAC_CELL_CONFIG_REQ");
+ break;
+ case EVENT_MAC_CELL_START:
+ strcpy(message,"EVENT_MAC_CELL_START");
+ break;
+ case EVENT_MAC_CELL_STOP:
+ strcpy(message,"EVENT_MAC_CELL_STOP");
+ break;
+ case EVENT_MAC_DL_CCCH_IND:
+ strcpy(message,"EVENT_MAC_DL_CCCH_IND");
+ break;
+ case EVENT_MAC_UE_CREATE_REQ:
+ strcpy(message,"EVENT_MAC_UE_CREATE_REQ");
+ break;
+ case EVENT_MAC_UE_RECONFIG_REQ:
+ strcpy(message,"EVENT_MAC_UE_RECONFIG_REQ");
+ break;
+ case EVENT_MAC_UE_DELETE_REQ:
+ strcpy(message,"EVENT_MAC_UE_DELETE_REQ");
+ break;
+ case EVENT_MAC_CELL_DELETE_REQ:
+ strcpy(message,"EVENT_MAC_CELL_DELETE_REQ");
+ break;
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ break;
+ }
+ case ENTRLC:
+ {
+ strcpy(sourceTask,"ENTRLC");
+ switch(pst->event)
+ {
+#ifdef LCRGUIRGU
+ case EVTRGUBNDREQ:
+ strcpy(message,"EVTRGUBNDREQ");
+ break;
+ case EVTRGUUBNDREQ:
+ strcpy(message,"EVTRGUUBNDREQ");
+ break;
+ case EVENT_DL_DATA_TO_MAC:
+ strcpy(message,"EVENT_DL_DATA_TO_MAC");
+ break;
+ case EVENT_BO_STATUS_TO_MAC:
+ strcpy(message,"EVENT_BO_STATUS_TO_MAC");
+ break;
+#endif
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+ }
+
+ break;
+ }
+ case ENTLWRMAC:
+ {
+ strcpy(sourceTask,"ENTLWRMAC");
+ switch(pst->event)
+ {
+ case EVENT_SLOT_IND_TO_MAC:
+ strcpy(message,"EVENT_SLOT_IND_TO_MAC");
+ break;
+ case EVENT_STOP_IND_TO_MAC:
+ strcpy(message,"EVENT_STOP_IND_TO_MAC");
+ break;
+ case EVENT_RACH_IND_TO_MAC:
+ strcpy(message,"EVENT_RACH_IND_TO_MAC");
+ break;
+ case EVENT_CRC_IND_TO_MAC:
+ strcpy(message,"EVENT_CRC_IND_TO_MAC");
+ break;
+ case EVENT_RX_DATA_IND_TO_MAC:
+ strcpy(message,"EVENT_RX_DATA_IND_TO_MAC");
+ break;
+ case EVENT_UCI_IND_TO_MAC:
+ strcpy(message,"EVENT_UCI_IND_TO_MAC");
+ break;
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+ }
+
+ break;
+ }
+ case ENTMAC: /* When scheduler instance sends msg to MAC */
+ {
+ strcpy(sourceTask,"ENTMAC");
+ switch(pst->event)
+ {
+#ifdef LCRG
+ case EVTINFCELLREGREQ:
+ strcpy(message,"EVTINFCELLREGREQ");
+ break;
+ case EVTINFSFALLOCREQ:
+ strcpy(message,"EVTINFSFALLOCREQ");
+ break;
+ case EVTINFRLSHQREQ:
+ strcpy(message,"EVTINFRLSHQREQ");
+ break;
+ case EVTINFHQENTRESET:
+ strcpy(message,"EVTINFHQENTRESET");
+ break;
+ case EVTINFRLSRNTIREQ:
+ strcpy(message,"EVTINFRLSRNTIREQ");
+ break;
+#ifdef LTEMAC_SPS
+ case EVTINFSPSLCREG:
+ strcpy(message,"EVTINFSPSLCREG");
+ break;
+ case EVTINFSPSLCDEREG:
+ strcpy(message,"EVTINFSPSLCDEREG");
+ break;
+ case EVTINFSPSRESET:
+ strcpy(message,"EVTINFSPSRESET");
+ break;
+#endif /* LTEMAC_SPS */
+ case EVTINFLCGREG:
+ strcpy(message,"EVTINFLCGREG");
+ break;
+#endif
+#if defined(LTE_ADV) && defined(LCPRG)
+ case EVTPRGUESCELLCFGREQ:
+ strcpy(message,"EVTPRGUESCELLCFGREQ");
+ break;
+ case EVTPRGUESCELLCFGCFM:
+ strcpy(message,"EVTPRGUESCELLCFGCFM");
+ break;
+ case EVTPRGUESCELLLCHMODCFM:
+ strcpy(message,"EVTPRGUESCELLLCHMODCFM");
+ break;
+ case EVTPRGUESCELLLCHDELCFMDEL:
+ strcpy(message,"EVTPRGUESCELLLCHDELCFMDEL");
+ break;
+ case EVTPRGUESCELLLCHADDCFM:
+ strcpy(message,"EVTPRGUESCELLLCHADDCFM");
+ break;
+ case EVTPRGUESCELLDELREQ:
+ strcpy(message,"EVTPRGUESCELLDELREQ");
+ break;
+ case EVTPRGUESCELLLCHMODREQ:
+ strcpy(message,"EVTPRGUESCELLLCHMODREQ");
+ break;
+ case EVTPRGUESCELLLCHDELREQ:
+ strcpy(message,"EVTPRGUESCELLLCHDELREQ");
+ break;
+ case EVTPRGUESCELLLCHADDREQ:
+ strcpy(message,"EVTPRGUESCELLLCHADDREQ");
+ break;
+
+#endif
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ break;
+ }
+
+ default:
+ {
+ strcpy(sourceTask,"Invalid Source Entity Id");
+ break;
+ }
+ }
+ DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+}
\f
+/**********************************************************************
+\f
/**
* @brief Task Activation callback function.
*
Buffer *mBuf /* message buffer */
)
{
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ callFlowRgActvTsk(pst);
+#endif
+
switch(pst->srcEnt)
{
/* The originator of this message is the stack manager,
{
uint16_t cellIdx;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UL_SCH_INFO\n");
+#endif
+
GET_CELL_IDX(ulSchedInfo->cellId, cellIdx);
if(ulSchedInfo != NULLP)
{
uint16_t cellIdx;
MacDlSlot *currDlSlot = NULLP;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_DL_SCH_INFO\n");
+#endif
if(dlSchedInfo != NULLP)
{
GET_CELL_IDX(dlSchedInfo->cellId, cellIdx);
uint16_t cellIdx;
MacUeCfg *ueCfg = NULLP;
+#ifdef CALL_FLOW_DEBUG_LOG
+ switch(pst->event)
+ {
+ case EVENT_UE_CONFIG_RSP_TO_MAC:
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_CONFIG_RSP_TO_MAC\n");
+ break;
+ case EVENT_UE_RECONFIG_RSP_TO_MAC:
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_RECONFIG_RSP_TO_MAC\n");
+ break;
+ default:
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : Invalid Event\n");
+ break;
+ }
+#endif
+
GET_CELL_IDX(schCfgRsp->cellId, cellIdx);
ueCfg = getMacUeCfg(cellIdx, schCfgRsp->ueIdx);
if(ueCfg == NULLP)
switch(pst->event)
{
case EVENT_UE_CONFIG_RSP_TO_MAC:
- {
- if(schCfgRsp->rsp != RSP_NOK)
- {
- DU_LOG("\nINFO --> MAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
- if(ret == ROK)
- {
- ret = procMacUeCfgData(pst, ueCfg);
- if(ret == ROK)
- {
- result = MAC_DU_APP_RSP_OK;
+ {
+ if(schCfgRsp->rsp != RSP_NOK)
+ {
+ DU_LOG("\nINFO --> MAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ if(ret == ROK)
+ {
+ ret = procMacUeCfgData(pst, ueCfg);
+ if(ret == ROK)
+ {
+ result = MAC_DU_APP_RSP_OK;
+ }
}
- }
- }
- else
- {
- DU_LOG("\nERROR --> MAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
- }
- ret = MacSendUeCreateRsp(result, schCfgRsp);
- }
- break;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ }
+ ret = MacSendUeCreateRsp(result, schCfgRsp);
+ }
+ break;
case EVENT_UE_RECONFIG_RSP_TO_MAC:
- {
- if(schCfgRsp->rsp != RSP_NOK)
- {
- DU_LOG("\nINFO --> MAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
- if(ret == ROK)
- {
- ret = procMacUeCfgData(pst, ueCfg);
- if(ret == ROK)
- {
- result = MAC_DU_APP_RSP_OK;
+ {
+
+ if(schCfgRsp->rsp != RSP_NOK)
+ {
+ DU_LOG("\nINFO --> MAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()",\
+ schCfgRsp->crnti);
+ if(ret == ROK)
+ {
+ ret = procMacUeCfgData(pst, ueCfg);
+ if(ret == ROK)
+ {
+ result = MAC_DU_APP_RSP_OK;
+ }
}
- }
- }
- else
- {
- DU_LOG("\nERROR --> MAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
- }
- ret = MacSendUeReconfigRsp(result, schCfgRsp);
- }
- break;
-
- default:
- break;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()",\
+ schCfgRsp->crnti);
+ }
+ ret = MacSendUeReconfigRsp(result, schCfgRsp);
+ }
+ break;
}
MAC_FREE(ueCfg, sizeof(MacUeCfg));
ueCfg = NULLP;
-
return ret;
}
uint16_t cellIdx=0;
uint8_t ret = RFAILED;
UeDeleteStatus result;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_DELETE_RSP_TO_MAC\n");
+#endif
if(schUeDelRsp)
{
return ROK;
} /* kwActvInit */
+/*
+*
+* @brief
+*
+* Function:
+* name : callFlowRlcDlActvTsk
+*
+* @b Description:
+* Function used to print values of src, dest, message
+* received at the layer
+*
+* @param[in] pst - Pst Structure
+*
+* @return void
+*/
+void callFlowRlcDlActvTsk(Pst *pst)
+{
+ char sourceTask[50];
+ char destTask[50]="ENTMAC";
+ char message[100];
+ switch(pst->srcEnt)
+ {
+ case ENTDUAPP:
+ {
+ strcpy(sourceTask,"ENTDUAPP");
+ switch(pst->event)
+ {
+#ifdef LCLKW
+ case LKW_EVT_CFG_REQ:
+ {
+ strcpy(message,"LKW_EVT_CFG_REQ");
+ break;
+ }
+
+ case LKW_EVT_CNTRL_REQ:
+ {
+ strcpy(message,"LKW_EVT_CNTRL_REQ");
+ break;
+ }
+
+ case LKW_EVT_STS_REQ:
+ {
+ strcpy(message,"LKW_EVT_STS_REQ");
+ break;
+ }
+
+ case LKW_EVT_STA_REQ:
+ {
+ strcpy(message,"LKW_EVT_STA_REQ");
+ break;
+ }
+ /* kw005.201 added support for L2 Measurement */
+#endif /* LCLKW */
+
+#ifdef LCKWU
+ case KWU_EVT_DAT_REQ: /* Data request */
+ {
+ strcpy(message,"KWU_EVT_DAT_REQ");
+ break;
+ }
+#endif /* LCKWU */
+
+ case EVENT_DL_RRC_MSG_TRANS_TO_RLC:
+ {
+ strcpy(message,"EVENT_DL_RRC_MSG_TRANS_TO_RLC");
+ break;
+ }
+ case EVENT_DL_USER_DATA_TRANS_TO_RLC:
+ {
+ strcpy(message,"EVENT_DL_USER_DATA_TRANS_TO_RLC");
+ break;
+ }
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ break;
+ }
+
+ case ENTRLC:
+ {
+
+ strcpy(sourceTask,"ENTRLC");
+ switch(pst->event)
+ {
+#ifdef LCUDX
+ case UDX_EVT_BND_REQ: /* Bind request */
+ {
+ strcpy(message,"UDX_EVT_BND_REQ");
+ break;
+ }
+
+ case UDX_EVT_UBND_REQ: /* Bind request */
+ {
+ strcpy(message,"UDX_EVT_UBND_REQ");
+ break;
+ }
+ case UDX_EVT_CFG_REQ: /* Unbind request */
+ {
+ strcpy(message,"UDX_EVT_CFG_REQ");
+ break;
+ }
+
+ case UDX_EVT_UEIDCHG_REQ: /* Configuration request */
+ {
+ strcpy(message,"UDX_EVT_UEIDCHG_REQ");
+ break;
+ }
+
+ case UDX_EVT_STA_UPD_REQ: /* Configuration request */
+ {
+ strcpy(message,"UDX_EVT_STA_UPD_REQ");
+ break;
+ }
+
+ case UDX_EVT_STA_PDU_REQ: /* Configuration request */
+ {
+ strcpy(message,"UDX_EVT_STA_PDU_REQ");
+ break;
+ }
+
+#endif /* LCCKW */
+ case UDX_EVT_DL_CLEANUP_MEM:
+ {
+ strcpy(message,"UDX_EVT_DL_CLEANUP_MEM");
+ break;
+ }
+
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+
+ }
+ break;
+ }
+
+ case ENTMAC:
+ {
+ strcpy(sourceTask,"ENTMAC");
+ switch(pst->event)
+ {
+#ifdef LCRGU
+ case EVTRGUBNDCFM: /* Bind request */
+ {
+ strcpy(message,"EVTRGUBNDCFM");
+ break;
+ }
+ case EVENT_SCHED_RESULT_TO_RLC:
+ {
+ strcpy(message,"EVENT_SCHED_RESULT_TO_RLC");
+ break;
+ }
+ /* kw005.201 added support for L2 Measurement */
+ case EVTRGUFLOWCNTRLIND:
+ {
+ strcpy(message,"EVTRGUFLOWCNTRLIND");
+ break;
+ }
+#endif /* LCRGU */
+#ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
+ case UDX_EVT_STA_UPD_REQ: /* Configuration request */
+ {
+ strcpy(message,"UDX_EVT_STA_UPD_REQ");
+ break;
+ }
+#endif
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+
+ }
+ break;
+ }
+ default:
+ {
+ strcpy(sourceTask,"Invalid Source Entity Id");
+ }
+ }
+ DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+}
\f
/**
*
gRlcTId = pthread_self();
#endif
+#ifdef CALL_FLOW_DEBUG_LOG
+ callFlowRlcDlActvTsk(pst);
+#endif
+
switch(pst->srcEnt)
{
case ENTDUAPP:
return ROK;
} /* rlcUlActvInit */
+/*
+* @brief
+*
+* Function:
+* name : callFlowRlcUlActvTsk
+*
+* @b Description:
+* Function used to print values of src, dest, message
+* received at the layer
+*
+* @param[in] pst - Pst Structure
+*
+* @return void
+*/
+
+void callFlowRlcUlActvTsk(Pst *pst)
+{
+ char sourceTask[50];
+ char destTask[50]="ENTRLCUL";
+ char message[100];
+
+ switch(pst->srcEnt)
+ {
+ case ENTDUAPP:
+ {
+ strcpy(sourceTask,"ENTDUAPP");
+ switch(pst->event)
+ {
+#ifdef LCLKW
+ case LKW_EVT_CFG_REQ:
+ {
+ strcpy(message,"LKW_EVT_CFG_REQ");
+ break;
+ }
+
+ case LKW_EVT_CNTRL_REQ:
+ {
+ strcpy(message,"LKW_EVT_CNTRL_REQ");
+ break;
+ }
+
+ case EVENT_RLC_UE_CREATE_REQ: /* UE Create Request */
+ {
+ strcpy(message,"EVENT_RLC_UE_CREATE_REQ");
+ break;
+ }
+ case EVENT_RLC_UE_RECONFIG_REQ: /* UE Reconfig Request */
+ {
+ strcpy(message,"EVENT_RLC_UE_RECONFIG_REQ");
+ break;
+ }
+ case EVENT_RLC_UE_DELETE_REQ:
+ {
+ strcpy(message,"EVENT_RLC_UE_DELETE_REQ");
+ break;
+ }
+
+ case LKW_EVT_STS_REQ:
+ {
+ strcpy(message,"LKW_EVT_STS_REQ");
+ break;
+ }
+
+ case LKW_EVT_STA_REQ:
+ {
+ strcpy(message,"LKW_EVT_STA_REQ");
+ break;
+ }
+ /* kw005.201 added support for L2 Measurement */
+#endif /* LCLKW */
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ }
+ break;
+ }
+
+ case ENTRLC:
+ {
+ strcpy(sourceTask,"ENTRLC");
+ switch(pst->event)
+ {
+#ifdef LCUDX
+ case UDX_EVT_BND_CFM: /* Bind request */
+ {
+ strcpy(message,"UDX_EVT_BND_CFM");
+ break;
+ }
+
+ case UDX_EVT_CFG_CFM: /* Unbind request */
+ {
+ strcpy(message,"UDX_EVT_CFG_CFM");
+ break;
+ }
+
+ case UDX_EVT_UEIDCHG_CFM: /* Configuration request */
+ {
+ strcpy(message,"UDX_EVT_UEIDCHG_CFM");
+ break;
+ }
+
+ case UDX_EVT_STA_PHBT_TMR_START: /* Status Prohibit Timer Start */
+ {
+ strcpy(message,"UDX_EVT_STA_PHBT_TMR_START");
+ break;
+ }
+
+#endif /* LCCKW */
+
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+
+ }
+ break;
+ }
+
+ case ENTMAC:
+ {
+ strcpy(sourceTask,"ENTMAC");
+ switch(pst->event)
+ {
+#ifdef LCRGU
+ case EVTRGUBNDCFM: /* Bind request */
+ {
+ strcpy(message,"EVTRGUBNDCFM");
+ break;
+ }
+
+ case EVENT_UL_DATA_TO_RLC: /* UL Data request */
+ {
+ strcpy(message,"EVENT_UL_DATA_TO_RLC");
+ break;
+ }
+
+#endif /* LCRGU */
+
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ break;
+ }
+ default:
+ {
+ strcpy(sourceTask,"Invalid Source Entity Id");
+ }
+ }
+ DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+
+}
+
+
+\f
\f
/**
*
{
S16 ret = ROK;
+#ifdef CALL_FLOW_DEBUG_LOG
+ callFlowRlcUlActvTsk(pst);
+#endif
switch(pst->srcEnt)
{
RgMngmt cfm;
Pst cfmPst;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : GENERAL_CFG_REQ\n");
+#endif
+
if(pst->dstInst < SCH_INST_START)
{
DU_LOG("\nERROR --> SCH : Invalid inst ID");
{
Inst inst = pst->dstInst-SCH_INST_START;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SLOT_IND_TO_SCH\n");
+#endif
+
schProcessSlotInd(slotInd, inst);
return ROK;
uint8_t MacSchRachInd(Pst *pst, RachIndInfo *rachInd)
{
Inst inst = pst->dstInst-SCH_INST_START;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_RACH_IND_TO_SCH\n");
+#endif
+
DU_LOG("\nINFO --> SCH : Received Rach indication");
schProcessRachInd(rachInd, inst);
return ROK;
* ****************************************************************/
uint8_t MacSchCrcInd(Pst *pst, CrcIndInfo *crcInd)
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_CRC_IND_TO_SCH\n");
+#endif
+
switch(crcInd->crcInd[0])
{
case CRC_FAILED:
Pst rspPst;
Inst inst = pst->dstInst-1;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SCH_CELL_CFG\n");
+#endif
+
schInitCellCb(inst, schCellCfg);
cellCb = schCb[inst].cells[inst]; //cells is of MAX_CELLS, why inst
cellCb->macInst = pst->srcInst;
schCellCfgCfm.rsp = RSP_OK;
ret = (*SchCellCfgCfmOpts[rspPst.selector])(&rspPst, &schCellCfgCfm);
-
return ret;
}
SchUeCb *ueCb = NULLP;
SchCellCb *cell = NULLP;
SchDlSlotInfo *schDlSlotInfo = NULLP;
-
Inst inst = pst->dstInst-SCH_INST_START;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_DL_RLC_BO_INFO_TO_SCH\n");
+#endif
+
DU_LOG("\nDEBUG --> SCH : Received RLC BO Status indication");
cell = schCb[inst].cells[inst];
SchUeCb *ueCb = NULLP;
uint8_t lcgIdx;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SHORT_BSR\n");
+#endif
+
DU_LOG("\nDEBUG --> SCH : Received BSR");
cellCb = schCb[schInst].cells[schInst];
ueCb = schGetUeCb(cellCb, bsrInd->crnti);
SchUeCb *ueCb;
SchCellCb *cellCb = schCb[inst].cells[inst];
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_UCI_IND_TO_SCH\n");
+#endif
+
DU_LOG("\nDEBUG --> SCH : Received SR");
ueCb = schGetUeCb(cellCb, uciInd->crnti);
#include "rg_sch.x" /* typedefs for Scheduler */
#include "mac_sch_interface.h"
+/*
+* @brief
+*
+* Function:
+* name : callFlowSchActvTsk
+*
+* @b Description:
+* Function used to print values of src, dest, message
+* received at the layer
+*
+* @param[in] pst - Pst Structure
+*
+* @return void
+*/
+
+void callFlowSchActvTsk(Pst *pst)
+{
+ char sourceTask[50];
+ char destTask[50]="ENTSCH";
+ char message[100];
+
+ switch(pst->srcEnt)
+ {
+ case ENTMAC: /* When MAC sends a msg to Scheduler instance */
+ {
+ strcpy(sourceTask,"ENTMAC");
+ switch(pst->event)
+ {
+#ifdef LCSCH
+ case EVTINFDEDBOUPDTREQ:
+ strcpy(message,"EVTINFDEDBOUPDTREQ");
+ break;
+ case EVTINFCMNBOUPDTREQ:
+ strcpy(message,"EVTINFCMNBOUPDTREQ");
+ break;
+ case EVTINFSFRECPIND:
+ strcpy(message,"EVTINFSFRECPIND");
+ break;
+ /*Fix: start: Inform UE delete to scheduler*/
+ case EVTINFUEDELIND:
+ strcpy(message,"EVTINFUEDELIND");
+ break;
+ /*Fix: end: Inform UE delete to scheduler*/
+#ifdef LTE_L2_MEAS
+ case EVTINFL2MEASCFM:
+ strcpy(message,"EVTINFL2MEASCFM");
+ break;
+ case EVTINFL2MEASSTOPCFM:
+ strcpy(message,"EVTINFL2MEASSTOPCFM");
+ break;
+#endif
+#endif
+ case EVENT_SLOT_IND_TO_SCH:
+ strcpy(message,"EVENT_SLOT_IND_TO_SCH");
+ break;
+ default:
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ break;
+ }
+ default:
+ strcpy(sourceTask,"Invalid Source Entity Id");
+ break;
+ }
+ DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+}
-\f
/**
* @brief Task Activation callback function.
*
Buffer *mBuf /* message buffer */
)
{
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ callFlowSchActvTsk(pst);
+#endif
+
switch(pst->srcEnt)
{
/* The originator of this message is the stack manager,
memset(&pst, 0, sizeof(Pst));
FILL_PST_SCH_TO_MAC(pst, inst);
- pst.event = EVENT_DL_ALLOC;
+ pst.event = EVENT_DL_SCH_INFO;
return(*schMacDlAllocOpts[pst.selector])(&pst, dlSchedInfo);
SchUeCfgRsp cfgRsp;
Inst inst = pst->dstInst - 1;
memset(&cfgRsp, 0, sizeof(SchUeCfgRsp));
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_ADD_UE_CONFIG_REQ_TO_SCH\n");
+#endif
if(!ueCfg)
{
SchUeCfgRsp cfgRsp;
Inst inst = pst->dstInst - 1;
memset(&cfgRsp, 0, sizeof(SchUeCfgRsp));
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_MODIFY_UE_CONFIG_REQ_TO_SCH\n");
+#endif
if(!ueCfg)
{
ErrorCause result;
SchCellCb *cellCb = NULLP;
Inst inst = pst->dstInst - 1;
-
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_UE_DELETE_REQ_TO_SCH\n");
+#endif
+
if(!ueDelete)
{
DU_LOG("\nERROR --> SCH : MacSchUeDeleteReq(): Ue Delete request failed");
uint8_t cellIdx=0, ret = RFAILED;
Inst inst = pst->dstInst - 1;
SchMacRsp result= RSP_OK;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_CELL_DELETE_REQ_TO_SCH\n");
+#endif
if(!cellDelete)
{
/* events */
#define EVENT_SCH_CELL_CFG 1
#define EVENT_SCH_CELL_CFG_CFM 2
-#define EVENT_DL_ALLOC 3
+#define EVENT_DL_SCH_INFO 3
#define EVENT_UL_SCH_INFO 4
#define EVENT_RACH_IND_TO_SCH 5
#define EVENT_CRC_IND_TO_SCH 6
return ROK;
}
+/**************************************************************************
+* @brief Function prints the src dest and msg reached to egtp.
+*
+* @details
+*
+* Function : callFlowEgtpActvTsk
+*
+* Functionality:
+* Function prints the src dest and msg reached to egtp.
+*
+* @param[in] Pst *pst, Post structure of the primitive.
+*
+* @return void
+*
+***************************************************************************/
+
+void callFlowEgtpActvTsk(Pst *pst)
+{
+
+ char sourceTask[50];
+ char destTask[50]="ENTEGTP";
+ char message[100];
+
+ switch(pst->srcEnt)
+ {
+ case ENTDUAPP:
+ {
+ strcpy(sourceTask,"ENTDUAPP");
+ switch(pst->event)
+ {
+ case EVTCFGREQ:
+ {
+ strcpy(message,"EVTCFGREQ");
+ break;
+ }
+ case EVTSRVOPENREQ:
+ {
+ strcpy(message,"EVTSRVOPENREQ");
+ break;
+ }
+ case EVTTNLMGMTREQ:
+ {
+ strcpy(message,"EVTTNLMGMTREQ");
+ break;
+ }
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ }
+ break;
+ }
+ case ENTEGTP:
+ {
+ strcpy(sourceTask,"ENTEGTP");
+ switch(pst->event)
+ {
+ case EVTSTARTPOLL:
+ {
+ strcpy(message,"EVTSTARTPOLL");
+ break;
+ }
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ }
+ break;
+ }
+ case ENTRLC:
+ {
+ strcpy(sourceTask,"ENTRLC");
+ switch(pst->event)
+ {
+ case EVTDATIND:
+ {
+ strcpy(message,"EVTDATIND");
+ break;
+ }
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ }
+ break;
+ }
+ default:
+ {
+ strcpy(sourceTask,"Invalid Source Entity Id");
+ }
+ }
+ DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+}
/**************************************************************************
* @brief Task Activation callback function.
uint8_t egtpActvTsk(Pst *pst, Buffer *mBuf)
{
uint8_t ret = ROK;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ callFlowEgtpActvTsk(pst);
+#endif
switch(pst->srcEnt)
{
{
uint8_t ret = ROK;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTDUAPP -> ENTEGTP : TNL_MGMT\n");
+#endif
+
DU_LOG("\nDEBUG --> EGTP : Received tunnel management request");
switch(tnlEvt.action)
{
uint32_t msgLen;
EgtpMsgHdr *msgHdr;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTDUAPP -> ENTEGTP : DATA_INDICATION\n");
+#endif
+
DU_LOG("\nDEBUG --> EGTP : Received Data Indication");
cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(egtpMsg.msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
}
+/**************************************************************************
+* @brief Function prints the src dest and msg reached to egtp.
+*
+* @details
+*
+* Function : callFlowduActvTsk
+*
+* Functionality:
+* Function prints the src dest and msg reached to egtp.
+*
+* @param[in] Pst *pst, Post structure of the primitive.
+*
+* @return void
+*
++***************************************************************************/
+
+void callFlowduActvTsk(Pst *pst)
+{
+ char sourceTask[50];
+ char destTask[50]="ENTDUAPP";
+ char message[100];
+
+ switch(pst->srcEnt)
+ {
+ case ENTDUAPP:
+ {
+ strcpy(sourceTask,"ENTDUAPP");
+ switch(pst->event)
+ {
+ case EVTCFG:
+ {
+ strcpy(message,"EVTCFG");
+ break;
+ }
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ }
+
+ break;
+ }
+ case ENTRLC:
+ {
+ strcpy(sourceTask,"ENTRLC");
+ switch(pst->event)
+ {
+ case LKW_EVT_CFG_CFM:
+ {
+ strcpy(message,"LKW_EVT_CFG_CFM");
+ break;
+ }
+ case LKW_EVT_CNTRL_CFM:
+ {
+ strcpy(message,"LKW_EVT_CNTRL_CFM");
+ break;
+ }
+ case LKW_EVT_STA_IND:
+ {
+ strcpy(message,"LKW_EVT_STA_IND");
+ break;
+ }
+ case EVENT_RLC_UE_CREATE_RSP:
+ {
+ strcpy(message,"EVENT_RLC_UE_CREATE_RSP");
+ break;
+ }
+ case EVENT_RLC_UE_RECONFIG_RSP:
+ {
+ strcpy(message,"EVENT_RLC_UE_RECONFIG_RSP");
+ break;
+ }
+ case EVENT_RLC_UE_DELETE_RSP:
+ {
+ strcpy(message,"EVENT_RLC_UE_DELETE_RSP");
+ break;
+ }
+ case EVENT_UL_RRC_MSG_TRANS_TO_DU:
+ {
+ strcpy(message,"EVENT_UL_RRC_MSG_TRANS_TO_DU");
+ break;
+ }
+ case EVENT_RRC_DELIVERY_MSG_TRANS_TO_DU:
+ {
+ strcpy(message,"EVENT_RRC_DELIVERY_MSG_TRANS_TO_DU");
+ break;
+ }
+ case EVENT_DL_RRC_MSG_RSP_TO_DU:
+ {
+ strcpy(message,"EVENT_DL_RRC_MSG_RSP_TO_DU");
+ break;
+ }
+ case EVENT_UL_USER_DATA_TRANS_TO_DU:
+ {
+ strcpy(message,"EVENT_UL_USER_DATA_TRANS_TO_DU");
+ break;
+ }
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ }
+ }
+ break;
+ }
+ case ENTMAC:
+ {
+ strcpy(sourceTask,"ENTMAC");
+ switch(pst->event)
+ {
+ case EVTCFG:
+ {
+ strcpy(message,"EVTCFG");
+ break;
+ }
+ case EVTLRGCFGCFM:
+ {
+ strcpy(message,"EVTLRGCFGCFM");
+ break;
+ }
+ case EVTLRGCNTRLCFM:
+ {
+ strcpy(message,"EVTLRGCNTRLCFM");
+ break;
+ }
+ case EVTMACSCHGENCFGCFM:
+ {
+ strcpy(message,"EVTMACSCHGENCFGCFM");
+ break;
+ }
+ case EVENT_MAC_CELL_CONFIG_CFM:
+ {
+ strcpy(message,"EVENT_MAC_CELL_CONFIG_CFM");
+ break;
+ }
+ case EVENT_MAC_CELL_UP_IND:
+ {
+ strcpy(message,"EVENT_MAC_CELL_UP_IND");
+ break;
+ }
+ case EVENT_MAC_STOP_IND:
+ {
+ strcpy(message,"EVENT_MAC_STOP_IND");
+ break;
+ }
+ case EVENT_MAC_UL_CCCH_IND:
+ {
+ strcpy(message,"EVENT_MAC_UL_CCCH_IND");
+ break;
+ }
+ case EVENT_MAC_UE_CREATE_RSP:
+ {
+ strcpy(message,"EVENT_MAC_UE_CREATE_RSP");
+ break;
+ }
+ case EVENT_MAC_UE_RECONFIG_RSP:
+ {
+ strcpy(message,"EVENT_MAC_UE_RECONFIG_RSP");
+ break;
+ }
+ case EVENT_MAC_UE_DELETE_RSP:
+ {
+ strcpy(message,"EVENT_MAC_UE_DELETE_RSP");
+ break;
+ }
+ case EVENT_MAC_CELL_DELETE_RSP:
+ {
+ strcpy(message,"EVENT_MAC_CELL_DELETE_RSP");
+ break;
+ }
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ }
+
+ break;
+ }
+ case ENTSCTP:
+ {
+ strcpy(sourceTask,"ENTSCTP");
+ switch(pst->event)
+ {
+ case EVENT_CU_DATA:
+ {
+ strcpy(message,"EVENT_CU_DATA");
+ break;
+ }
+ case EVENT_SCTP_NTFY:
+ {
+ strcpy(message,"EVENT_SCTP_NTFY");
+ break;
+ }
+ case EVENT_RIC_DATA:
+ {
+ strcpy(message,"EVENT_RIC_DATA");
+ break;
+ }
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ break;
+ }
+
+ }
+ break;
+ }
+ case ENTEGTP:
+ {
+ strcpy(sourceTask,"ENTEGTP");
+ switch(pst->event)
+ {
+ case EVTCFGCFM:
+ {
+ strcpy(message,"EVTCFGCFM");
+ break;
+ }
+ case EVTSRVOPENCFM:
+ {
+ strcpy(message,"EVTSRVOPENCFM");
+ break;
+ }
+ case EVTTNLMGMTCFM:
+ {
+ strcpy(message,"EVTTNLMGMTCFM");
+ break;
+ }
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ }
+ break;
+ }
+ default:
+ {
+ strcpy(sourceTask,"Invalid Source Entity Id");
+ break;
+ }
+ }
+ DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+}
/**************************************************************************
* @brief Task Activation callback function.
*
uint8_t duActvTsk(Pst *pst, Buffer *mBuf)
{
uint8_t ret = ROK;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ callFlowduActvTsk(pst);
+#endif
switch(pst->srcEnt)
{
}
+/**************************************************************************
+* @brief Function prints src, dest, msg infor about all the msgs that received.
+*
+* @details
+*
+* Function : callFlowSctpActvTsk
+*
+* Function prints src, dest, msg infor about all the msgs that received
+*
+* @param[in] Pst *pst, Post structure of the primitive.
+*
+* @return void
+***************************************************************************/
+uint8_t callFlowSctpActvTsk(Pst *pst)
+{
+ char sourceTask[50];
+ char destTask[50]="ENTSCTP";
+ char message[100];
+
+ switch(pst->srcEnt)
+ {
+ case ENTDUAPP:
+ {
+ strcpy(sourceTask,"ENTDUAPP");
+ switch(pst->event)
+ {
+ case EVTSTARTPOLL:
+ {
+ strcpy(message,"EVTSTARTPOLL");
+ break;
+ }
+ }
+ break;
+ }
+ }
+ DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+}
+
/**************************************************************************
* @brief Task Activation callback function.
*
***************************************************************************/
uint8_t sctpActvTsk(Pst *pst, Buffer *mBuf)
{
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ callFlowSctpActvTsk(pst);
+#endif
+
+
switch(pst->srcEnt)
{
case ENTDUAPP:
uint8_t ret = ROK;
CmStatus cfm;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_CFG_REQ_TO_SCTP\n");
+#endif
/* Fill F1 Params */
f1Params.destIpAddr.ipV4Pres = sctpCfg.cuIpAddr.ipV4Pres;
f1Params.destIpAddr.ipV4Addr = sctpCfg.cuIpAddr.ipV4Addr;
CmStatus cfm;
DuSctpDestCb *paramPtr = NULLP;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_ASSOC_REQ_TO_SCTP\n");
+#endif
+
DU_ALLOC(paramPtr, sizeof(DuSctpDestCb));
if(paramPtr == NULLP)
{
}
else
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ if(pollParams->port == f1Params.destPort)
+ DU_LOG("\nCall Flow: CU -> ENTSCTP : EVENT_SCTP_MSG\n");
+ else
+ DU_LOG("\nCall Flow: RIC -> ENTSCTP : EVENT_SCTP_MSG\n");
+#endif
if((((pollParams->flag & CM_INET_SCTP_MSG_NOTIFICATION) != 0)) && ret == ROK)
{
if(pollParams->port == f1Params.destPort)
memInfo.region = DU_APP_MEM_REGION;
memInfo.pool = DU_POOL;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ if(itfType == F1_INTERFACE)
+ {
+ DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_F1AP_MSG_TO_SCTP\n");
+ }
+ else
+ {
+ DU_LOG("\nCall Flow: ENTDUAPP -> ENTSCTP : EVENT_E2AP_MSG_TO_SCTP\n");
+ }
+#endif
if(itfType == F1_INTERFACE)
{
- DU_LOG("\nDEBUG --> SCTP : sending the message to DuApp");
+ DU_LOG("\nDEBUG --> SCTP : sending the message to CU");
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTSCTP -> CU : EVENT_F1AP_MSG_TO_CU\n");
+#endif
ret = cmInetSctpSendMsg(&f1Params.sockFd, &f1Params.destIpNetAddr, f1Params.destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK);
}
if(itfType == E2_INTERFACE)
{
DU_LOG("\nDEBUG --> SCTP : sending the message to ric");
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTSCTP -> RIC : EVENT_E2AP_MSG_TO_RIC\n");
+#endif
ret = cmInetSctpSendMsg(&ricParams.sockFd, &ricParams.destIpNetAddr, ricParams.destPort, &memInfo, mBuf, &len, 0, FALSE, 0, 0/*SCT_PROTID_NONE*/, RWOULDBLOCK);
}
uint8_t duHdlEgtpDlData(EgtpMsg *egtpMsg)
{
uint16_t msgLen = 0;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTEGTP -> ENTDUAPP : EVENT_HDL_RECV_DL_DATA\n");
+#endif
+
DU_LOG("\nDEBUG --> DU_APP : Processing DL data in duHdlEgtpDlData()");
if(!egtpMsg->msg)
return ROK;
}
+/**************************************************************************
+* @brief Function prints the src dest and msg reached to egtp.
+*
+* @details
+*
+* Function : callFlowPhyStubActvTsk
+*
+* Functionality:
+* Function prints the src dest and msg reached to egtp.
+*
+* @param[in] Pst *pst, Post structure of the primitive.
+*
+* @return void
+*
+***************************************************************************/
+
+void callFlowPhyStubActvTsk(Pst *pst)
+{
+ char sourceTask[50];
+ char destTask[50]="PHY";
+ char message[100];
+ switch(pst->srcEnt)
+ {
+ case ENTPHYSTUB:
+ {
+ strcpy(sourceTask,"PHY");
+ switch(pst->event)
+ {
+ case EVT_PHY_START_SLOT_IND:
+ {
+ strcpy(message,"EVT_PHY_START_SLOT_IND");
+ break;
+ }
+ default:
+ {
+ strcpy(message,"Invalid Event");
+ break;
+ }
+ }
+ }
+ }
+ DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
+}
/*******************************************************************
*
* @brief Receives messages for Phy stub slot indication generator task
uint8_t phyStubActvTsk(Pst *pst, Buffer *mBuf)
{
DU_LOG("\nPHY_STUB: Received Event [%d]", pst->event);
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ callFlowPhyStubActvTsk(pst);
+#endif
+
switch(pst->srcEnt)
{
case ENTPHYSTUB: