# 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;
{
SchCellCfg schCellCfg;
Pst cfgPst;
- uint8_t ret =0;
+ uint8_t idx=0, ret=0;
memset(&cfgPst, 0, sizeof(Pst));
memset(&schCellCfg, 0, sizeof(SchCellCfg));
macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8;
schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 =
macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16;
- schCellCfg.schInitialDlBwp.pdschCommon.k0 = macCellCfg->initialDlBwp.pdschCommon.k0;
- schCellCfg.schInitialDlBwp.pdschCommon.mappingType =
- macCellCfg->initialDlBwp.pdschCommon.mappingType;
- schCellCfg.schInitialDlBwp.pdschCommon.startSymbol =
- macCellCfg->initialDlBwp.pdschCommon.startSymbol;
- schCellCfg.schInitialDlBwp.pdschCommon.lengthSymbol =
- macCellCfg->initialDlBwp.pdschCommon.lengthSymbol;
+ schCellCfg.schInitialDlBwp.pdschCommon.numTimeDomAlloc = macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc;
+ for(idx = 0; idx<macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc; idx++)
+ {
+ schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].k0 =
+ macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].k0;
+ schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].mappingType =
+ macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].mappingType;
+ schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].startSymbol =
+ macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].startSymbol;
+ schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].lengthSymbol =
+ macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].lengthSymbol;
+ }
/* fill initial UL BWP */
schCellCfg.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialUlBwp.bwp.firstPrb;
schCellCfg.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialUlBwp.bwp.numPrb;
schCellCfg.schInitialUlBwp.bwp.scs = macCellCfg->initialUlBwp.bwp.scs;
schCellCfg.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->initialUlBwp.bwp.cyclicPrefix;
- schCellCfg.schInitialUlBwp.puschCommon.k2 = macCellCfg->initialUlBwp.puschCommon.k2;
- schCellCfg.schInitialUlBwp.puschCommon.mappingType =
- macCellCfg->initialUlBwp.puschCommon.mappingType;
- schCellCfg.schInitialUlBwp.puschCommon.startSymbol =
- macCellCfg->initialUlBwp.puschCommon.startSymbol;
- schCellCfg.schInitialUlBwp.puschCommon.lengthSymbol =
- macCellCfg->initialUlBwp.puschCommon.lengthSymbol;
+ schCellCfg.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc = \
+ macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc;
+ for(idx = 0; idx < macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc; idx++)
+ {
+ schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[idx].k2 =
+ macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[idx].k2;
+ schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[idx].mappingType =
+ macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[idx].mappingType;
+ schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[idx].startSymbol =
+ macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[idx].startSymbol;
+ schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[idx].symbolLength =
+ macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[idx].symbolLength;
+ }
#ifdef NR_TDD
memcpy(&schCellCfg.tddCfg, &macCellCfg->tddCfg, sizeof(TDDCfg));
#endif
{
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);
for(idx = 0; idx < schPdschCfg->numTimeDomRsrcAlloc; idx++)
{
+ if(macPdschCfg.timeDomRsrcAllociList[idx].k0)
+ {
+ MAC_ALLOC(schPdschCfg->timeDomRsrcAllociList[idx].k0, sizeof(uint8_t));
+ if(!schPdschCfg->timeDomRsrcAllociList[idx].k0)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failed for K0 in fillInitDlBwpPdschCfg()");
+ return RFAILED;
+ }
+ *(schPdschCfg->timeDomRsrcAllociList[idx].k0) = *(macPdschCfg.timeDomRsrcAllociList[idx].k0);
+ }
schPdschCfg->timeDomRsrcAllociList[idx].mappingType = \
macPdschCfg.timeDomRsrcAllociList[idx].mappingType;
schPdschCfg->timeDomRsrcAllociList[idx].startSymbol = \
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,
uint16_t tbSize = 0;
cell = schCb[schInst].cells[schInst];
- startSymb = cell->cellCfg.schInitialUlBwp.puschCommon.startSymbol;
- symbLen = cell->cellCfg.schInitialUlBwp.puschCommon.lengthSymbol;
+ startSymb = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[0].startSymbol;
+ symbLen = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[0].symbolLength;
startRb = cell->schUlSlotInfo[msg3SlotAlloc]->puschCurrentPrb;
tbSize = schCalcTbSize(8); /* 6 bytes msg3 and 2 bytes header */
//puschMu = cell->cellCfg.puschMu;
delta = puschDeltaTable[puschMu];
- k2 = cell->cellCfg.schInitialUlBwp.puschCommon.k2;
+ k2 = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[0].k2;
/* RAR will sent with a delay of RAR_DELAY */
rarSlot = (rachInd->timingInfo.slot+RAR_DELAY+PHY_DELTA_DL)%cell->numSlots;
#ifdef NR_TDD
sib1PdschFreqAlloc = &schCb[inst].cells[inst]->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc;
pdsch->pdschFreqAlloc.freqAlloc.startPrb = sib1PdschFreqAlloc->startPrb + sib1PdschFreqAlloc->numPrb + 1;
}
- pdsch->pdschFreqAlloc.freqAlloc.numPrb = schCalcNumPrb(tbSize, mcs, initialBwp->pdschCommon.lengthSymbol);
+ pdsch->pdschFreqAlloc.freqAlloc.numPrb = schCalcNumPrb(tbSize, mcs, \
+ initialBwp->pdschCommon.timeDomRsrcAllocList[0].lengthSymbol);
pdsch->pdschFreqAlloc.vrbPrbMapping = 0; /* non-interleaved */
- pdsch->pdschTimeAlloc.timeAlloc.startSymb = initialBwp->pdschCommon.startSymbol;
- pdsch->pdschTimeAlloc.timeAlloc.numSymb = initialBwp->pdschCommon.lengthSymbol;
+ pdsch->pdschTimeAlloc.timeAlloc.startSymb = initialBwp->pdschCommon.timeDomRsrcAllocList[0].startSymbol;
+ pdsch->pdschTimeAlloc.timeAlloc.numSymb = initialBwp->pdschCommon.timeDomRsrcAllocList[0].lengthSymbol;
pdsch->beamPdschInfo.numPrgs = 1;
pdsch->beamPdschInfo.prgSize = 1;
pdsch->beamPdschInfo.digBfInterfaces = 0;
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)
{
* ****************************************************************/
void deleteSchUeCb(SchUeCb *ueCb)
{
+ uint8_t timeDomRsrcIdx;
SchPucchCfg *pucchCfg = NULLP;
+ SchPdschConfig *pdschCfg = NULLP;
+
if(ueCb)
{
SCH_FREE(ueCb->ueCfg.ambrCfg, sizeof(SchAmbrCfg));
if(ueCb->ueCfg.spCellCfgPres)
{
+ if(ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdschCfgPres == true)
+ {
+ pdschCfg = &ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdschCfg;
+ for(timeDomRsrcIdx = 0; timeDomRsrcIdx < pdschCfg->numTimeDomRsrcAlloc; timeDomRsrcIdx++)
+ SCH_FREE(pdschCfg->timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
+ }
+
if(ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfgPres == true)
{
pucchCfg = &ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfg;
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)
{
uint8_t raSearchSpaceId;
}PdcchConfigCommon;
-typedef struct pdschConfigCommon
+typedef struct pdschCfgCommTimeDomRsrcAlloc
{
uint8_t k0;
uint8_t mappingType;
uint8_t startSymbol;
uint8_t lengthSymbol;
+}PdschCfgCommTimeDomRsrcAlloc;
+
+typedef struct pdschConfigCommon
+{
+ uint8_t numTimeDomAlloc;
+ /* PDSCH time domain DL resource allocation list */
+ PdschCfgCommTimeDomRsrcAlloc timeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
}PdschConfigCommon;
typedef struct pucchConfigCommon
uint8_t pucchGroupHopping;
}PucchConfigCommon;
+/* PUSCH Time Domain Resource Allocation */
+typedef struct puschTimeDomRsrcAlloc
+{
+ uint8_t k2;
+ CommonMappingType mappingType;
+ uint8_t startSymbol;
+ uint8_t symbolLength;
+ uint8_t startSymbolAndLength;
+}PuschTimeDomRsrcAlloc;
+
+
typedef struct puschConfigCommon
{
/* PUSCH-TimeDomainResourceAllocation info */
- uint8_t k2;
- uint8_t mappingType;
- uint8_t startSymbol;
- uint8_t lengthSymbol;
+ uint8_t numTimeDomRsrcAlloc;
+ PuschTimeDomRsrcAlloc timeDomRsrcAllocList[MAX_NUM_UL_ALLOC]; /* PUSCH time domain UL resource allocation list */
}PuschConfigCommon;
typedef struct bwpDlConfig
/* PDSCH time domain resource allocation */
typedef struct pdschTimeDomRsrcAlloc
{
+ uint8_t *k0;
CommonMappingType mappingType;
uint8_t startSymbol;
uint8_t symbolLength;
TransPrecodDisabled transPrecodDisabled; /* Transform precoding disabled */
}DmrsUlCfg;
-/* PUSCH Time Domain Resource Allocation */
-typedef struct puschTimeDomRsrcAlloc
-{
- uint8_t k2;
- CommonMappingType mappingType;
- uint8_t startSymbol;
- uint8_t symbolLength;
- uint8_t startSymbolAndLength;
-}PuschTimeDomRsrcAlloc;
-
/* PUSCH Configuration */
typedef struct puschCfg
{
/* 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
uint8_t raSearchSpaceId;
}SchPdcchCfgCmn;
-typedef struct schPdschCfgCmn
+typedef struct schPdschCfgCmnTimeDomRsrcAlloc
{
uint8_t k0;
uint8_t mappingType;
uint8_t startSymbol;
uint8_t lengthSymbol;
+}SchPdschCfgCmnTimeDomRsrcAlloc;
+
+typedef struct schPdschCfgCmn
+{
+ uint8_t numTimeDomAlloc;
+ SchPdschCfgCmnTimeDomRsrcAlloc timeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
}SchPdschCfgCmn;
typedef struct schPucchCfgCmn
uint8_t pucchGroupHopping;
}SchPucchCfgCmn;
+/* PUSCH Time Domain Resource Allocation */
+typedef struct schPuschTimeDomRsrcAlloc
+{
+ uint8_t k2;
+ SchTimeDomRsrcAllocMappingType mappingType;
+ uint8_t startSymbol;
+ uint8_t symbolLength;
+}SchPuschTimeDomRsrcAlloc;
+
typedef struct schPuschCfgCmn
{
- uint8_t k2;
- uint8_t mappingType;
- uint8_t startSymbol;
- uint8_t lengthSymbol;
+ uint8_t numTimeDomRsrcAlloc;
+ SchPuschTimeDomRsrcAlloc timeDomRsrcAllocList[MAX_NUM_UL_ALLOC]; /* PUSCH time domain UL resource allocation list */
}SchPuschCfgCmn;
typedef struct schBwpDlCfg
/* PDSCH time domain resource allocation */
typedef struct schPdschTimeDomRsrcAlloc
{
+ uint8_t *k0;
SchTimeDomRsrcAllocMappingType mappingType;
uint8_t startSymbol;
uint8_t symbolLength;
SchTransPrecodDisabled transPrecodDisabled; /* Transform precoding disabled */
}SchDmrsUlCfg;
-/* PUSCH Time Domain Resource Allocation */
-typedef struct schPuschTimeDomRsrcAlloc
-{
- uint8_t k2;
- SchTimeDomRsrcAllocMappingType mappingType;
- uint8_t startSymbol;
- uint8_t symbolLength;
-}SchPuschTimeDomRsrcAlloc;
-
/* PUSCH Configuration */
typedef struct schPuschCfg
{
#include "SRS-Resource.h"
#include "SRS-ResourceSet.h"
#include "SRS-Config.h"
+#include "PUCCH-Config.h"
#include "BWP-UplinkDedicated.h"
#include "PUSCH-ServingCellConfig.h"
#include "UplinkConfig.h"
#define PDSCH_MAPPING_TYPE_B 1
/* MACRO Define for PUSCH Configuration */
-#define PUSCH_K2 3
+#define PUSCH_K2_CFG1 3
+#define PUSCH_K2_CFG2 4
#define PUSCH_MSG3_DELTA_PREAMBLE 0
#define PUSCH_P0_NOMINAL_WITH_GRANT -70
return RFAILED;
}
- elementCnt = 1;
+ elementCnt = 2;
timeDomAllocList->choice.setup->list.count = elementCnt;
timeDomAllocList->choice.setup->list.size = \
elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
idx = 0;
timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_ALLOC(timeDomAlloc->k0, sizeof(long));
+ if(!timeDomAlloc->k0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k0) = 0;
+ timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = 66;
- timeDomAlloc->k0 = NULLP;
+ idx++;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_ALLOC(timeDomAlloc->k0, sizeof(long));
+ if(!timeDomAlloc->k0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k0) = 1;
timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
timeDomAlloc->startSymbolAndLength = 66;
return RFAILED;
}
- elementCnt = 1;
+ elementCnt = 2;
timeDomAllocList->choice.setup->list.count = elementCnt;
timeDomAllocList->choice.setup->list.size = \
elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
- *(timeDomAlloc->k2) = PUSCH_K2;
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
timeDomAlloc->startSymbolAndLength = 66;
+
+ idx++;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_ALLOC(timeDomAlloc->k2, sizeof(long));
+ if(!timeDomAlloc->k2)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
+ timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = 66;
+
return ROK;
}
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Builds BWP UL dedicated PUCCH Config
+ *
+ * @details
+ *
+ * Function : BuildBWPUlDedPucchCfg
+ *
+ * Functionality:
+ * Builds BWP UL dedicated PUCCH Config
+ *
+ * @params[in] : PUCCH_Config_t *pucchCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
+{
+ uint8_t arrIdx, elementCnt;
+
+ CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
+ if(pucchCfg->dl_DataToUL_ACK == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ elementCnt = 2;
+ pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
+ pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
+ CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
+ if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx < pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
+ {
+ CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
+ if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+ }
+
+ arrIdx = 0;
+ *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
+ *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
+
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Fills SRS resource to add/modify list
uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
{
ulBwp->pucch_Config = NULLP;
+ ulBwp->pucch_Config = NULLP;
+ CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
+ if(!ulBwp->pucch_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
+ ulBwp->pucch_Config->choice.setup = NULLP;
+ CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
+ if(!ulBwp->pucch_Config->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
/* Fill BWP UL dedicated PUSCH config */
ulBwp->pusch_Config = NULLP;
/* This function is used to fill up the cell configuration for CL */
uint8_t readMacCfg()
{
+ uint8_t idx;
+
duCfgParam.macCellCfg.carrierId = CARRIER_IDX;
/* Cell configuration */
candidate.aggLevel8 = 1;
duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.
candidate.aggLevel16 = 0;
- duCfgParam.macCellCfg.initialDlBwp.pdschCommon.k0 = PDSCH_K0;
- duCfgParam.macCellCfg.initialDlBwp.pdschCommon.mappingType =
+
+ duCfgParam.macCellCfg.initialDlBwp.pdschCommon.numTimeDomAlloc = 2;
+ idx = 0;
+ duCfgParam.macCellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].k0 = PDSCH_K0_CFG1;
+ duCfgParam.macCellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].mappingType =
PDSCH_MAPPING_TYPE_A;
- duCfgParam.macCellCfg.initialDlBwp.pdschCommon.startSymbol =
+ duCfgParam.macCellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].startSymbol =
PDSCH_START_SYMBOL;
- duCfgParam.macCellCfg.initialDlBwp.pdschCommon.lengthSymbol =
+ duCfgParam.macCellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].lengthSymbol =
PDSCH_LENGTH_SYMBOL;
+ idx++;
+ duCfgParam.macCellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].k0 = PDSCH_K0_CFG2;
+ duCfgParam.macCellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].mappingType =
+ PDSCH_MAPPING_TYPE_A;
+ duCfgParam.macCellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].startSymbol =
+ PDSCH_START_SYMBOL;
+ duCfgParam.macCellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[idx].lengthSymbol =
+ PDSCH_LENGTH_SYMBOL;
+
/* ra-searchSpace ID is set to 1 */
duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpaceId = SEARCHSPACE_1_INDEX;
duCfgParam.macCellCfg.initialUlBwp.bwp.scs = SCS_15KHZ; /* numerology is 0, 15Khz */
#endif
duCfgParam.macCellCfg.initialUlBwp.bwp.cyclicPrefix = NORMAL_CYCLIC_PREFIX;
- duCfgParam.macCellCfg.initialUlBwp.puschCommon.k2 = PUSCH_K2;
- duCfgParam.macCellCfg.initialUlBwp.puschCommon.mappingType =
+ duCfgParam.macCellCfg.initialUlBwp.puschCommon.numTimeDomRsrcAlloc = 2;
+ duCfgParam.macCellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[0].k2 = PUSCH_K2_CFG1;
+ duCfgParam.macCellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[0].mappingType =
PUSCH_MAPPING_TYPE_A;
- duCfgParam.macCellCfg.initialUlBwp.puschCommon.startSymbol =
+ duCfgParam.macCellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[0].startSymbol =
PUSCH_START_SYMBOL;
- duCfgParam.macCellCfg.initialUlBwp.puschCommon.lengthSymbol =
+ duCfgParam.macCellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[0].symbolLength =
+ PUSCH_LENGTH_SYMBOL;
+
+ duCfgParam.macCellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[1].k2 = PUSCH_K2_CFG2;
+ duCfgParam.macCellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[1].mappingType =
+ PUSCH_MAPPING_TYPE_A;
+ duCfgParam.macCellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[1].startSymbol =
+ PUSCH_START_SYMBOL;
+ duCfgParam.macCellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[1].symbolLength =
PUSCH_LENGTH_SYMBOL;
duCfgParam.macCellCfg.dmrsTypeAPos = DMRS_TYPE_A_POS;
+
/* fill PUCCH config common */
duCfgParam.macCellCfg.initialUlBwp.pucchCommon.pucchResourceCommon = PUCCH_RSRC_COMMON;
duCfgParam.macCellCfg.initialUlBwp.pucchCommon.pucchGroupHopping = PUCCH_GROUP_HOPPING;
/* Configuring PDSCH Config Common For SIB1 */
pdschCfg.present = BWP_DownlinkCommon__pdsch_ConfigCommon_PR_setup;
- pdschCfg.k0 = PDSCH_K0;
- pdschCfg.mapType = \
+ pdschCfg.numTimeDomRsrcAlloc = 2;
+ pdschCfg.timeDomAlloc[0].k0 = PDSCH_K0_CFG1;
+ pdschCfg.timeDomAlloc[0].mapType = \
+ PDSCH_TimeDomainResourceAllocation__mappingType_typeA;
+ pdschCfg.timeDomAlloc[0].sliv = calcSliv(PDSCH_START_SYMBOL,PDSCH_LENGTH_SYMBOL);
+ pdschCfg.timeDomAlloc[1].k0 = PDSCH_K0_CFG2;
+ pdschCfg.timeDomAlloc[1].mapType = \
PDSCH_TimeDomainResourceAllocation__mappingType_typeA;
- pdschCfg.sliv = calcSliv(PDSCH_START_SYMBOL,PDSCH_LENGTH_SYMBOL);
+ pdschCfg.timeDomAlloc[1].sliv = calcSliv(PDSCH_START_SYMBOL,PDSCH_LENGTH_SYMBOL);
+
srvCellCfgComm->dlCfg.pdschCfg = pdschCfg;
/* Configuring BCCH Config for SIB1 */
srvCellCfgComm->ulCfg.rachCfg = rachCfg;
/* Configuring PUSCH Config Common for SIB1 */
- puschCfg.present = BWP_UplinkCommon__pusch_ConfigCommon_PR_setup;
- puschCfg.k2 = PUSCH_K2;
- puschCfg.mapType = PUSCH_TimeDomainResourceAllocation__mappingType_typeA;
- puschCfg.sliv = calcSliv(PUSCH_START_SYMBOL,PUSCH_LENGTH_SYMBOL);
+ puschCfg.puschCfgPresent = BWP_UplinkCommon__pusch_ConfigCommon_PR_setup;
+ puschCfg.numTimeDomRsrcAlloc = 2;
+ puschCfg.timeDomAllocList[0].k2 = PUSCH_K2_CFG1;
+ puschCfg.timeDomAllocList[0].mapType = PUSCH_TimeDomainResourceAllocation__mappingType_typeA;
+ puschCfg.timeDomAllocList[0].sliv = calcSliv(PUSCH_START_SYMBOL,PUSCH_LENGTH_SYMBOL);
+ puschCfg.timeDomAllocList[1].k2 = PUSCH_K2_CFG2;
+ puschCfg.timeDomAllocList[1].mapType = PUSCH_TimeDomainResourceAllocation__mappingType_typeA;
+ puschCfg.timeDomAllocList[1].sliv = calcSliv(PUSCH_START_SYMBOL,PUSCH_LENGTH_SYMBOL);
puschCfg.msg3DeltaPreamble = PUSCH_MSG3_DELTA_PREAMBLE;
puschCfg.p0NominalWithGrant = PUSCH_P0_NOMINAL_WITH_GRANT;
srvCellCfgComm->ulCfg.puschCfg = puschCfg;
#define SIB1_VALUE_TAG 10
/* MACRO Ddefine for PDSCH Configuration */
-#define PDSCH_K0 0
+#define PDSCH_K0_CFG1 0
+#define PDSCH_K0_CFG2 1
#define PDSCH_START_SYMBOL 3
#define PDSCH_LENGTH_SYMBOL 11
#define PDSCH_RES_ALLOC_TYPE 1 /* Resource allocation type */
#define PDSCH_NUM_HARQ_PROC 5
/* MACRO Define for PUSCH Configuration */
-#define PUSCH_K2 3
+#define MAX_UL_ALLOC 16
+#define PUSCH_K2_CFG1 3
+#define PUSCH_K2_CFG2 4
#define PUSCH_START_SYMBOL 3
#define PUSCH_LENGTH_SYMBOL 11
long raSearchSpc; /* Id of search space for Random Access proc */
}PdcchCfgCommon;
-typedef struct pdschCfgCommon
+typedef struct pdschTimeDomainRsrcAlloc
{
- uint8_t present;
long k0;
long mapType; /* Mapping Type */
uint16_t sliv;
+}PdschTimeDomainRsrcAlloc;
+
+typedef struct pdschCfgCommon
+{
+ uint8_t present;
+ uint8_t numTimeDomRsrcAlloc;
+ PdschTimeDomainRsrcAlloc timeDomAlloc[MAX_NUM_DL_ALLOC];
}PdschCfgCommon;
typedef struct bcchCfg
long restrictedSetCfg; /* Restricted set configuration */
}RachCfgCommon;
-typedef struct puschCfgCommon
+typedef struct puschCfgCmnTimeDomAlloc
{
- uint8_t present;
long k2;
long mapType;
uint16_t sliv;
+}PuschCfgCmnTimeDomAlloc;
+
+typedef struct puschCfgCommon
+{
+ uint8_t puschCfgPresent;
+ uint8_t numTimeDomRsrcAlloc;
+ PuschCfgCmnTimeDomAlloc timeDomAllocList[MAX_UL_ALLOC];
long msg3DeltaPreamble;
long p0NominalWithGrant;
}PuschCfgCommon;
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);
return RFAILED;
}
- elementCnt = 1;
+ elementCnt = 2;
timeDomAllocList->choice.setup->list.count = elementCnt;
timeDomAllocList->choice.setup->list.size = \
elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
idx = 0;
timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
-
- timeDomAlloc->k0 = NULLP;
+ DU_ALLOC(timeDomAlloc->k0, sizeof(long));
+ if(!timeDomAlloc->k0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k0) = 0;
timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
timeDomAlloc->startSymbolAndLength = \
calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
+ idx++;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ DU_ALLOC(timeDomAlloc->k0, sizeof(long));
+ if(!timeDomAlloc->k0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k0) = 1;
+ timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
+
return ROK;
}
return RFAILED;
}
- elementCnt = 1;
+ elementCnt = 2;
timeDomAllocList->choice.setup->list.count = elementCnt;
timeDomAllocList->choice.setup->list.size = \
elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
- *(timeDomAlloc->k2) = PUSCH_K2;
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
+ timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
+
+ idx++;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ DU_ALLOC(timeDomAlloc->k2, sizeof(long));
+ if(!timeDomAlloc->k2)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
+
return ROK;
}
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Builds BWP UL dedicated PUCCH Config
+ *
+ * @details
+ *
+ * Function : BuildBWPUlDedPucchCfg
+ *
+ * Functionality:
+ * Builds BWP UL dedicated PUCCH Config
+ *
+ * @params[in] : PUCCH_Config_t *pucchCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
+{
+ uint8_t arrIdx, elementCnt;
+
+ DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
+ if(pucchCfg->dl_DataToUL_ACK == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ elementCnt = 2;
+ pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
+ pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
+ DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
+ if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx < pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
+ {
+ DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
+ if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+ }
+
+ arrIdx = 0;
+ *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
+ *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Fills SRS resource to add/modify list
uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
{
ulBwp->pucch_Config = NULLP;
+ DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
+ if(!ulBwp->pucch_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
+ ulBwp->pucch_Config->choice.setup = NULLP;
+ DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
+ if(!ulBwp->pucch_Config->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
/* Fill BWP UL dedicated PUSCH config */
ulBwp->pusch_Config = NULLP;
*
* @return void
*
- 4221 * ****************************************************************/
+ * ****************************************************************/
void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
{
uint8_t idx1=0;
{
if(timeDomAllocList->choice.setup->list.array)
{
- for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
- {
- DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
- sizeof(struct PDSCH_TimeDomainResourceAllocation));
- }
- DU_FREE(timeDomAllocList->choice.setup->list.array, \
- timeDomAllocList->choice.setup->list.size);
+ for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
+ {
+ DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
+ DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
+ sizeof(struct PDSCH_TimeDomainResourceAllocation));
+ }
+ DU_FREE(timeDomAllocList->choice.setup->list.array, \
+ timeDomAllocList->choice.setup->list.size);
}
DU_FREE(timeDomAllocList->choice.setup,\
- sizeof(struct PDSCH_TimeDomainResourceAllocationList));
+ sizeof(struct PDSCH_TimeDomainResourceAllocationList));
}
}
/*******************************************************************
* ****************************************************************/
void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
{
- uint8_t rSetIdx, rsrcIdx;
+ uint8_t rSetIdx, rsrcIdx, k1Idx;
SRS_Config_t *srsCfg = NULLP;
PUSCH_Config_t *puschCfg = NULLP;
+ PUCCH_Config_t *pucchCfg = NULLP;
struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
+ if(ulBwp->pucch_Config)
+ {
+ if(ulBwp->pucch_Config->choice.setup)
+ {
+ pucchCfg = ulBwp->pucch_Config->choice.setup;
+ if(pucchCfg->dl_DataToUL_ACK)
+ {
+ if(pucchCfg->dl_DataToUL_ACK->list.array)
+ {
+ for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
+ {
+ DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
+ }
+ DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
+ }
+ DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
+ }
+ DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
+ }
+ DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
+ }
+
if(ulBwp->pusch_Config)
{
if(ulBwp->pusch_Config->choice.setup)
{
- puschCfg=ulBwp->pusch_Config->choice.setup;
- if(puschCfg->dataScramblingIdentityPUSCH)
- {
- if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
- {
- FreePuschTimeDomAllocList(puschCfg);
- dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
- if(dmrsUlCfg->choice.setup)
- {
- if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
- {
- if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
- {
- DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
- sizeof(long));
- DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
- sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
- }
- DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
- sizeof(long));
- }
- DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
- }
- DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
- sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
- }
- DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
- }
- DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
+ puschCfg=ulBwp->pusch_Config->choice.setup;
+ if(puschCfg->dataScramblingIdentityPUSCH)
+ {
+ if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
+ {
+ FreePuschTimeDomAllocList(puschCfg);
+ dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
+ if(dmrsUlCfg->choice.setup)
+ {
+ if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
+ {
+ if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
+ {
+ DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
+ sizeof(long));
+ DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
+ sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
+ }
+ DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
+ sizeof(long));
+ }
+ DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
+ }
+ DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
+ sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
+ }
+ DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
+ }
+ DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
}
DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
/* Free SRS-Config */
if(ulBwp->srs_Config)
{
- if(ulBwp->srs_Config->choice.setup)
- {
- srsCfg = ulBwp->srs_Config->choice.setup;
+ if(ulBwp->srs_Config->choice.setup)
+ {
+ srsCfg = ulBwp->srs_Config->choice.setup;
- /* Free Resource Set to add/mod list */
- if(srsCfg->srs_ResourceSetToAddModList)
- {
- rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
- if(rsrcSetList->list.array)
- {
- rSetIdx = 0;
+ /* Free Resource Set to add/mod list */
+ if(srsCfg->srs_ResourceSetToAddModList)
+ {
+ rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
+ if(rsrcSetList->list.array)
+ {
+ rSetIdx = 0;
- /* Free SRS resource Id list in this SRS resource set */
- if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
- {
- rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
+ /* Free SRS resource Id list in this SRS resource set */
+ if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
+ {
+ rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
- if(rsrcIdList->list.array)
- {
- for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
- {
- DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
- }
- DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
- }
- DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
- sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
- }
+ if(rsrcIdList->list.array)
+ {
+ for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
+ {
+ DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
+ }
+ DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
+ }
+ DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
+ sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
+ }
- /* Free resource type info for this SRS resource set */
- DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
- sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
+ /* Free resource type info for this SRS resource set */
+ DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
+ sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
- /* Free memory for each resource set */
- for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
- {
- DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
- }
- DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
- }
- DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
- sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
- }
+ /* Free memory for each resource set */
+ for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
+ {
+ DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
+ }
+ DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
+ }
+ DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
+ sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
+ }
- /* Free resource to add/modd list */
- if(srsCfg->srs_ResourceToAddModList)
- {
- resourceList = srsCfg->srs_ResourceToAddModList;
- if(resourceList->list.array)
- {
- rsrcIdx = 0;
- DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
- sizeof(struct SRS_Resource__transmissionComb__n2));
- DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
- sizeof(struct SRS_Resource__resourceType__aperiodic));
+ /* Free resource to add/modd list */
+ if(srsCfg->srs_ResourceToAddModList)
+ {
+ resourceList = srsCfg->srs_ResourceToAddModList;
+ if(resourceList->list.array)
+ {
+ rsrcIdx = 0;
+ DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
+ sizeof(struct SRS_Resource__transmissionComb__n2));
+ DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
+ sizeof(struct SRS_Resource__resourceType__aperiodic));
- for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
- {
- DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
- }
- DU_FREE(resourceList->list.array, resourceList->list.size);
- }
- DU_FREE(srsCfg->srs_ResourceToAddModList, \
- sizeof(struct SRS_Config__srs_ResourceToAddModList));
- }
+ for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
+ {
+ DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
+ }
+ DU_FREE(resourceList->list.array, resourceList->list.size);
+ }
+ DU_FREE(srsCfg->srs_ResourceToAddModList, \
+ sizeof(struct SRS_Config__srs_ResourceToAddModList));
+ }
- DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
- }
- DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
+ DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
+ }
+ DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
}
}
}
{
if(rlcBearerList->list.array)
{
- for(idx=0; idx<rlcBearerList->list.count; idx++)
- {
- if(rlcBearerList->list.array[idx])
- {
- rlcConfig = rlcBearerList->list.array[idx]->rlc_Config;
- macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
- if(rlcConfig)
- {
- if(rlcConfig->choice.am)
- {
- DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
- DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
- DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
- }
- DU_FREE(rlcConfig, sizeof(struct RLC_Config));
- }
- DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
- if(macLcConfig)
- {
- if(macLcConfig->ul_SpecificParameters)
- {
- DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
- DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
- DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
- }
- DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
- }
- DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
- }
- }
- DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
+ for(idx=0; idx<rlcBearerList->list.count; idx++)
+ {
+ if(rlcBearerList->list.array[idx])
+ {
+ rlcConfig = rlcBearerList->list.array[idx]->rlc_Config;
+ macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
+ if(rlcConfig)
+ {
+ if(rlcConfig->choice.am)
+ {
+ DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
+ }
+ DU_FREE(rlcConfig, sizeof(struct RLC_Config));
+ }
+ DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
+ if(macLcConfig)
+ {
+ if(macLcConfig->ul_SpecificParameters)
+ {
+ DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
+ DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
+ DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
+ }
+ DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
+ }
+ DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
+ }
+ }
+ DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
}
DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
}
schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
if(schedulingRequestConfig)
{
- schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
- if(schReqList)
- {
- if(schReqList->list.array)
- {
- for(idx=0;idx<schReqList->list.count; idx++)
- {
- if(schReqList->list.array[idx])
- {
- DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
- DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
- }
- }
- DU_FREE(schReqList->list.array, schReqList->list.size);
- }
- DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
- sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList)); }
- DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
+ schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
+ if(schReqList)
+ {
+ if(schReqList->list.array)
+ {
+ for(idx=0;idx<schReqList->list.count; idx++)
+ {
+ if(schReqList->list.array[idx])
+ {
+ DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
+ DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
+ }
+ }
+ DU_FREE(schReqList->list.array, schReqList->list.size);
+ }
+ DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
+ sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList)); }
+ DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
}
if(macCellGrpCfg->bsr_Config)
{
- DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
+ DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
}
tagConfig = macCellGrpCfg->tag_Config;
if(tagConfig)
{
- tagList = tagConfig->tag_ToAddModList;
- if(tagList)
- {
- if(tagList->list.array)
- {
- for(idx=0; idx<tagList->list.count; idx++)
- {
- DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
- }
- DU_FREE(tagList->list.array, tagList->list.size);
- }
- DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
- }
- DU_FREE(tagConfig, sizeof(struct TAG_Config));
+ tagList = tagConfig->tag_ToAddModList;
+ if(tagList)
+ {
+ if(tagList->list.array)
+ {
+ for(idx=0; idx<tagList->list.count; idx++)
+ {
+ DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
+ }
+ DU_FREE(tagList->list.array, tagList->list.size);
+ }
+ DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
+ }
+ DU_FREE(tagConfig, sizeof(struct TAG_Config));
}
phrConfig = macCellGrpCfg->phr_Config;
if(phrConfig)
{
- DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
- DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
+ DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
+ DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
}
DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
{
if(spCellCfg->servCellIndex)
{
- if(spCellCfg->rlmInSyncOutOfSyncThreshold)
- {
- if(spCellCfg->spCellConfigDedicated)
- {
- srvCellCfg = spCellCfg->spCellConfigDedicated;
- if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
- {
- if(srvCellCfg->initialDownlinkBWP)
- {
- dlBwp = srvCellCfg->initialDownlinkBWP;
- if(srvCellCfg->firstActiveDownlinkBWP_Id)
- {
- if(srvCellCfg->defaultDownlinkBWP_Id)
- {
- if(srvCellCfg->uplinkConfig)
- {
- if(srvCellCfg->pdsch_ServingCellConfig)
- {
- pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
- if(pdschCfg->choice.setup)
- {
- DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
- DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
- }
- DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
- ServingCellConfig__pdsch_ServingCellConfig));
- }
- FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
- DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
- }
- DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
- }
- DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
- }
- if(dlBwp->pdcch_Config)
- {
- if(dlBwp->pdsch_Config)
- {
- FreeBWPDlDedPdschCfg(dlBwp);
- DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
- }
- FreeBWPDlDedPdcchCfg(dlBwp);
- DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
- }
- DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
- }
- DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
- }
- DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
- }
- DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
- }
- DU_FREE(spCellCfg->servCellIndex, sizeof(long));
+ if(spCellCfg->rlmInSyncOutOfSyncThreshold)
+ {
+ if(spCellCfg->spCellConfigDedicated)
+ {
+ srvCellCfg = spCellCfg->spCellConfigDedicated;
+ if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
+ {
+ if(srvCellCfg->initialDownlinkBWP)
+ {
+ dlBwp = srvCellCfg->initialDownlinkBWP;
+ if(srvCellCfg->firstActiveDownlinkBWP_Id)
+ {
+ if(srvCellCfg->defaultDownlinkBWP_Id)
+ {
+ if(srvCellCfg->uplinkConfig)
+ {
+ if(srvCellCfg->pdsch_ServingCellConfig)
+ {
+ pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
+ if(pdschCfg->choice.setup)
+ {
+ DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
+ DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
+ }
+ DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
+ ServingCellConfig__pdsch_ServingCellConfig));
+ }
+ FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
+ DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
+ }
+ DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
+ }
+ DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
+ }
+ if(dlBwp->pdcch_Config)
+ {
+ if(dlBwp->pdsch_Config)
+ {
+ FreeBWPDlDedPdschCfg(dlBwp);
+ DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
+ }
+ FreeBWPDlDedPdcchCfg(dlBwp);
+ DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
+ }
+ DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
+ }
+ DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
+ }
+ DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
+ }
+ DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
+ }
+ DU_FREE(spCellCfg->servCellIndex, sizeof(long));
}
DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
}
* ****************************************************************/
void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
{
+ uint8_t timeDomRsrcIdx;
+
+ if(srvCellCfg->initDlBwp.pdschPresent)
+ {
+ for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
+ srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
+ }
+ }
+
freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
if(srvCellCfg->bwpInactivityTmr)
{
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
}
+
+ if(srvCellCfg->initUlBwp.pucchPresent)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
+ }
}
/*******************************************************************
if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
{
if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
- PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
+ PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
{
if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
- {
+ {
macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
- *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
- }
+ *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
+ }
}
}
macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
{
timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
if(timeDomAlloc->present ==\
- PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
+ PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
{
if(timeDomAlloc->choice.setup)
- {
- macPdschCfg->numTimeDomRsrcAlloc = timeDomAlloc->choice.setup->list.count;
+ {
+ macPdschCfg->numTimeDomRsrcAlloc = timeDomAlloc->choice.setup->list.count;
for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
{
- macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
- timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
- macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
- timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
- }
- }
+ macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
+ if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
+ {
+ if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
+ {
+ DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
+ if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
+ {
+ DU_LOG("\nERROR --> DU APP : Memory allocation failed for k0 at extractPdschCfg()");
+ return RFAILED;
+ }
+ }
+ *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
+ *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
+ }
+ macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
+ timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
+ macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
+ timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
+ }
+ }
}
}
macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
{
if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
- {
+ {
macPdschCfg->bundlingInfo.StaticBundling.size = \
- *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
- }
+ *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
+ }
}
}
else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
* @return void
*
* ****************************************************************/
-uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
+uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend, void *cellInfo)
{
uint8_t ret = ROK;
CellGroupConfigRrc_t *cellGrp = NULLP;
if(cellInfo)
{
cellGrp = (CellGroupConfigRrc_t *)cellInfo;
- ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
+ ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend);
if(ret == RFAILED)
DU_LOG("\nERROR --> F1AP : Failed at procUeReCfgCellInfo()");
}
if(ret == RFAILED)
{
- freeUeReCfgCellGrpInfo(macUeCfg);
+ freeUeReCfgCellGrpInfo(macUeCfgToSend);
}
return ret;
}
}
+/**************************************************************************
+* @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);
}
DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
return RFAILED;
}
- elementCnt = ODU_VALUE_ONE;
+ elementCnt = duPdschCfg.numTimeDomRsrcAlloc;
pdschSetup->pdsch_TimeDomainAllocationList->list.count = elementCnt;
pdschSetup->pdsch_TimeDomainAllocationList->list.size = elementCnt * sizeof(PDSCH_TimeDomainResourceAllocation_t *);
}
}
- idx = 0;
- timeDomRsrcAllocInfo = pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx];
-
- /* K0 */
- DU_ALLOC(timeDomRsrcAllocInfo->k0, sizeof(long));
- if(!timeDomRsrcAllocInfo->k0)
- {
- DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- *timeDomRsrcAllocInfo->k0 = duPdschCfg.k0;
-
- timeDomRsrcAllocInfo->mappingType = duPdschCfg.mapType;
- timeDomRsrcAllocInfo->startSymbolAndLength = duPdschCfg.sliv;
-
+ for(idx = 0; idx < pdschSetup->pdsch_TimeDomainAllocationList->list.count; idx++)
+ {
+ timeDomRsrcAllocInfo = pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx];
+
+ /* K0 */
+ DU_ALLOC(timeDomRsrcAllocInfo->k0, sizeof(long));
+ if(!timeDomRsrcAllocInfo->k0)
+ {
+ DU_LOG("\nERROR --> DU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *timeDomRsrcAllocInfo->k0 = duPdschCfg.timeDomAlloc[idx].k0;
+
+ timeDomRsrcAllocInfo->mappingType = duPdschCfg.timeDomAlloc[idx].mapType;
+ timeDomRsrcAllocInfo->startSymbolAndLength = duPdschCfg.timeDomAlloc[idx].sliv;
+ }
break;
}
default:
duPuschCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.puschCfg;
- puschCfg->present = duPuschCfg.present;
+ puschCfg->present = duPuschCfg.puschCfgPresent;
switch(puschCfg->present)
{
case BWP_UplinkCommon__pusch_ConfigCommon_PR_NOTHING:
DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
return RFAILED;
}
- elementCnt = ODU_VALUE_ONE;
+ elementCnt = duPuschCfg.numTimeDomRsrcAlloc;
setup->pusch_TimeDomainAllocationList->list.count = elementCnt;
setup->pusch_TimeDomainAllocationList->list.size = \
elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
}
}
- idx = 0;
- timeDomRsrcAllocInfo = setup->pusch_TimeDomainAllocationList->list.array[idx];
-
- /* K2 */
- DU_ALLOC(timeDomRsrcAllocInfo->k2, sizeof(long));
- if(!timeDomRsrcAllocInfo->k2)
- {
- DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
- return RFAILED;
- }
- *timeDomRsrcAllocInfo->k2 = duPuschCfg.k2;
-
- timeDomRsrcAllocInfo->mappingType = duPuschCfg.mapType;
- timeDomRsrcAllocInfo->startSymbolAndLength = duPuschCfg.sliv;
-
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ timeDomRsrcAllocInfo = setup->pusch_TimeDomainAllocationList->list.array[idx];
+
+ /* K2 */
+ DU_ALLOC(timeDomRsrcAllocInfo->k2, sizeof(long));
+ if(!timeDomRsrcAllocInfo->k2)
+ {
+ DU_LOG("\nERROR --> DU APP : PUSCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *timeDomRsrcAllocInfo->k2 = duPuschCfg.timeDomAllocList[idx].k2;
+ timeDomRsrcAllocInfo->mappingType = duPuschCfg.timeDomAllocList[idx].mapType;
+ timeDomRsrcAllocInfo->startSymbolAndLength = duPuschCfg.timeDomAllocList[idx].sliv;
+ }
/* Msg3 Delta Preamble */
DU_ALLOC(setup->msg3_DeltaPreamble, sizeof(long));
if(!setup->msg3_DeltaPreamble)
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)
initUlBwp->puschCfg.dmrsUlCfgForPuschMapTypeA.transPrecodDisabled. \
scramblingId0 = SCRAMBLING_ID;
initUlBwp->puschCfg.resourceAllocType = RESOURCEALLOCATION_TYPE1;
- initUlBwp->puschCfg.numTimeDomRsrcAlloc = 1;
+ initUlBwp->puschCfg.numTimeDomRsrcAlloc = 2;
idx = 0;
if(initUlBwp->puschCfg.numTimeDomRsrcAlloc <= MAX_NUM_UL_ALLOC)
{
- initUlBwp->puschCfg.timeDomRsrcAllocList[idx].k2 = PUSCH_K2;
+ initUlBwp->puschCfg.timeDomRsrcAllocList[idx].k2 = PUSCH_K2_CFG1;
initUlBwp->puschCfg.timeDomRsrcAllocList[idx].mappingType =\
MAPPING_TYPEA;
initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbol = PUSCH_START_SYMBOL;
initUlBwp->puschCfg.timeDomRsrcAllocList[idx].symbolLength = PUSCH_LENGTH_SYMBOL;
initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbolAndLength =\
calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
+
+ idx++;
+ initUlBwp->puschCfg.timeDomRsrcAllocList[idx].k2 = PUSCH_K2_CFG2;
+ initUlBwp->puschCfg.timeDomRsrcAllocList[idx].mappingType = MAPPING_TYPEA;
+ initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbol = PUSCH_START_SYMBOL;
+ initUlBwp->puschCfg.timeDomRsrcAllocList[idx].symbolLength = PUSCH_LENGTH_SYMBOL;
+ initUlBwp->puschCfg.timeDomRsrcAllocList[idx].startSymbolAndLength =\
+ calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
}
initUlBwp->puschCfg.transformPrecoder = TRANSFORM_PRECODER_DISABLED;
}
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:
-cd odu;make clean_odu MACHINE=BIT64 MODE=TDD;make odu MACHINE=BIT64 MODE=TDD COVERAGE=1
+sudo apt install -y libsctp-dev;cd odu;make clean_odu MACHINE=BIT64 MODE=TDD;make odu MACHINE=BIT64 MODE=TDD COVERAGE=1
Code Review / o-du / l2.git / commitdiff