* ****************************************************************/
uint8_t lwr_mac_procInvalidEvt(void *msg)
{
- printf("\nLWR_MAC: Error Indication Event[%d] received in state [%d]", lwrMacCb.event, lwrMacCb.phyState);
+ DU_LOG("\nERROR --> LWR_MAC: Error Indication Event[%d] received in state [%d]", lwrMacCb.event, lwrMacCb.phyState);
return ROK;
}
}
else
{
- DU_LOG("\nLWR_MAC: Value Extraction failed" );
+ DU_LOG("\nERROR --> LWR_MAC: Value Extraction failed" );
return RFAILED;
}
}
{
*mibPdu |= (((uint8_t)(sfn >> 2)) & MIB_SFN_BITMASK);
*val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
- DU_LOG("\nLWR_MAC: MIB PDU %x", *val);
+ DU_LOG("\nDEBUG --> LWR_MAC: MIB PDU %x", *val);
}
/*******************************************************************
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for param req header");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for param req header");
LWR_MAC_FREE(paramReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_param_req_t)));
return RFAILED;
}
msgHeader->num_msg = 1;
msgHeader->handle = 0;
- DU_LOG("\nLWR_MAC: Sending Param Request to Phy");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending Param Request to Phy");
LwrMacSendToL1(headerElem);
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for Param Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for Param Request");
return RFAILED;
}
#endif
ClCellParam *cellParam = NULLP;
paramRsp = (fapi_param_resp_t *)msg;
- DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
+ DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
if(paramRsp != NULLP)
{
MAC_ALLOC(cellParam, sizeof(ClCellParam));
if(cellParam != NULLP)
{
- DU_LOG("\n LWR_MAC: Filling TLVS into MAC API");
+ DU_LOG("\nDEBUG --> LWR_MAC: Filling TLVS into MAC API");
if(paramRsp->error_code == MSG_OK)
{
for(index = 0; index < paramRsp->number_of_tlvs; index++)
encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
if(encodedVal != RFAILED && encodedVal != lwrMacCb.phyState)
{
- printf("\n PhyState mismatch [%d][%d]", lwrMacCb.phyState, lwrMacCb.event);
+ DU_LOG("\nERROR --> PhyState mismatch [%d][%d]", lwrMacCb.phyState, lwrMacCb.event);
return RFAILED;
}
break;
}
break;
default:
- //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
+ //DU_LOG("\nERROR --> Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
break;
}
}
}
else
{
- DU_LOG("\n LWR_MAC: Invalid error code %d", paramRsp->error_code);
+ DU_LOG("\nERROR --> LWR_MAC: Invalid error code %d", paramRsp->error_code);
return RFAILED;
}
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for cell param");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for cell param");
return RFAILED;
}
}
else
{
- DU_LOG("\nLWR_MAC: Param Response received from PHY is NULL");
+ DU_LOG("\nERROR --> LWR_MAC: Param Response received from PHY is NULL");
return RFAILED;
}
#else
LWR_MAC_ALLOC(iqSampleElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_ext_iq_samples_req_t)));
if(!iqSampleElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for IQ sample req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for IQ sample req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(iqSampleElem, NULLP, FAPI_VENDOR_EXT_UL_IQ_SAMPLES, 1, \
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for FAPI header in lwr_mac_procIqSamplesReqEvt");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for FAPI header in lwr_mac_procIqSamplesReqEvt");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(headerElem, iqSampleElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
msgHeader->num_msg = 1;
msgHeader->handle = 0;
- DU_LOG("\nLWR_MAC: Sending IQ Sample request to Phy");
+ DU_LOG("\nINFO --> LWR_MAC: Sending IQ Sample request to Phy");
LwrMacSendToL1(headerElem);
return ROK;
}
p_fapi_api_queue_elem_t vendorMsgQElem;
p_fapi_api_queue_elem_t cfgReqQElem;
- DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
+ DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
lwrMacCb.phyState);
cellId = (uint16_t *)msg;
LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgQElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(vendorMsgQElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
LWR_MAC_ALLOC(cfgReqQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_config_req_t)));
if(!cfgReqQElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for config req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for config req");
LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
}
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
LWR_MAC_ALLOC(cfgReqQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_config_req_t)));
LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
msgHeader->num_msg = 2; /* Config req msg and vendor specific msg */
msgHeader->handle = 0;
- DU_LOG("\nLWR_MAC: Sending Config Request to Phy");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending Config Request to Phy");
LwrMacSendToL1(headerElem);
#endif
fapi_config_resp_t *configRsp;
configRsp = (fapi_config_resp_t *)msg;
- DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
+ DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
lwrMacCb.phyState);
if(configRsp != NULL)
{
if(configRsp->error_code == MSG_OK)
{
- DU_LOG("\nLWR_MAC: PHY has moved to Configured state \n");
+ DU_LOG("\nDEBUG --> LWR_MAC: PHY has moved to Configured state \n");
lwrMacCb.phyState = PHY_STATE_CONFIGURED;
lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED;
/* TODO :
}
else
{
- DU_LOG("\n LWR_MAC: Invalid error code %d", configRsp->error_code);
+ DU_LOG("\nERROR --> LWR_MAC: Invalid error code %d", configRsp->error_code);
return RFAILED;
}
}
else
{
- DU_LOG("\nLWR_MAC: Config Response received from PHY is NULL");
+ DU_LOG("\nERROR --> LWR_MAC: Config Response received from PHY is NULL");
return RFAILED;
}
#endif
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in start req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in start req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(vendorMsgElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
LWR_MAC_ALLOC(startReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_start_req_t)));
if(!startReqElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for start req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for start req");
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
}
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
LWR_MAC_ALLOC(startReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_start_req_t)));
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
msgHeader->handle = 0;
/* Send to PHY */
- DU_LOG("\nLWR_MAC: Sending Start Request to Phy");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending Start Request to Phy");
LwrMacSendToL1(headerElem);
#endif
return ROK;
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in stop req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in stop req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(vendorMsgElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
LWR_MAC_ALLOC(stopReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_stop_req_t)));
if(!stopReqElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for stop req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for stop req");
LWR_MAC_FREE(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
}
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for header in stop req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for header in stop req");
LWR_MAC_FREE(stopReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_stop_req_t)));
LWR_MAC_FREE(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
msgHeader->handle = 0;
/* Send to PHY */
- DU_LOG("\nLWR_MAC: Sending Stop Request to Phy");
+ DU_LOG("\nINFO --> LWR_MAC: Sending Stop Request to Phy");
LwrMacSendToL1(headerElem);
#endif
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
}
else
{
- DU_LOG("\nLWR_MAC: Failed filling PDCCH Pdu");
+ DU_LOG("\nERROR --> LWR_MAC: Failed filling PDCCH Pdu");
return RFAILED;
}
dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for header in DL TTI req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for header in DL TTI req");
LWR_MAC_FREE(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_dl_tti_req_t)));
return RFAILED;
}
numPduEncoded++;
}
}
- printf("\033[1;31m");
- DU_LOG("\nLWR_MAC: MIB sent..");
- printf("\033[0m");
+ DU_LOG("\033[1;31m");
+ DU_LOG("\nDEBUG --> LWR_MAC: MIB sent..");
+ DU_LOG("\033[0m");
}
if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
{
pduIndex++;
numPduEncoded++;
}
- printf("\033[1;34m");
- DU_LOG("\nLWR_MAC: SIB1 sent...");
- printf("\033[0m");
+ DU_LOG("\033[1;34m");
+ DU_LOG("\nDEBUG --> LWR_MAC: SIB1 sent...");
+ DU_LOG("\033[0m");
}
}
if(currDlSlot->dlInfo.rarAlloc != NULLP)
numPduEncoded++;
pduIndex++;
- printf("\033[1;32m");
- DU_LOG("\nLWR_MAC: RAR sent...");
- printf("\033[0m");
+ DU_LOG("\033[1;32m");
+ DU_LOG("\nDEBUG --> LWR_MAC: RAR sent...");
+ DU_LOG("\033[0m");
}
if(currDlSlot->dlInfo.dlMsgAlloc != NULLP)
{
if(currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPdu != NULLP)
{
/* Filling Msg4 param */
- printf("\033[1;32m");
+ DU_LOG("\033[1;32m");
if(currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.isMsg4Pdu)
{
rntiType = TC_RNTI_TYPE;
fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
&currDlSlot->dlInfo, rntiType, CORESET_TYPE0);
- DU_LOG("\nLWR_MAC: MSG4 sent...");
+ DU_LOG("\nDEBUG --> LWR_MAC: MSG4 sent...");
}
else
{
rntiType = C_RNTI_TYPE;
fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
&currDlSlot->dlInfo, rntiType, CORESET_TYPE1);
- DU_LOG("\nLWR_MAC: DL MSG sent...");
+ DU_LOG("\nDEBUG --> LWR_MAC: DL MSG sent...");
}
- printf("\033[0m");
+ DU_LOG("\033[0m");
numPduEncoded++;
fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
}
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nLWR_MAC: Sending DL TTI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
#endif
LwrMacSendToL1(headerElem);
else
{
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nLWR_MAC: Sending DL TTI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
#endif
LwrMacSendToL1(headerElem);
}
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for DL TTI Request");
memset(currDlSlot, 0, sizeof(MacDlSlot));
return RFAILED;
}
LWR_MAC_ALLOC(txDataElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_tx_data_req_t)));
if(txDataElem == NULLP)
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for TX data Request");
return RFAILED;
}
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for TxDataReq header");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for TxDataReq header");
LWR_MAC_FREE(txDataElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_tx_data_req_t)));
return RFAILED;
}
msgHeader->num_msg = 1;
msgHeader->handle = 0;
- DU_LOG("\nLWR_MAC: Sending TX DATA Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending TX DATA Request");
LwrMacSendToL1(headerElem);
}
#endif
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for UL TTI req header");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for UL TTI req header");
LWR_MAC_FREE(ulTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_tti_req_t)));
return RFAILED;
}
msgHeader->num_msg = 1;
msgHeader->handle = 0;
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nLWR_MAC: Sending UL TTI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request");
#endif
LwrMacSendToL1(headerElem);
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL TTI Request");
memset(currUlSlot, 0, sizeof(MacUlSlot));
return RFAILED;
}
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for UL DCI req header");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for UL DCI req header");
LWR_MAC_FREE(ulDciElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_dci_req_t)));
return RFAILED;
}
msgHeader->num_msg = 1;
msgHeader->handle = 0;
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nLWR_MAC: Sending UL DCI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending UL DCI Request");
#endif
LwrMacSendToL1(headerElem);
}
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for UL DCI Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL DCI Request");
memset(currDlSlot, 0, sizeof(MacDlSlot));
return RFAILED;
}
Pst pst;
Buffer *mBuf;
- DU_LOG("\nLWR MAC: Requesting to start WLS receiver thread");
+ DU_LOG("\nINFO --> LWR MAC : Requesting to start WLS receiver thread");
/* Filling post */
memset(&pst, 0, sizeof(Pst));
if (ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf) != ROK)
{
- DU_LOG("\nLWR MAC : Memory allocation failed for LwrMacStartWlsRcvr");
+ DU_LOG("\nERROR --> LWR MAC : Memory allocation failed for LwrMacStartWlsRcvr");
return;
}
continue;
}
- printf("\nLWR_MAC: numMsgToGet %d", numMsgToGet);
+ DU_LOG("\nDEBUG --> LWR_MAC : numMsgToGet %d", numMsgToGet);
while(numMsgToGet--)
{
currElem = NULLP;
addWlsBlockToFree(currMsg, msgLen, (slotIndIdx-1));
if(currMsg->p_next == NULLP)
{
- DU_LOG("\nThere cannot be only one block to send");
+ DU_LOG("\nERROR --> LWR MAC : There cannot be only one block to send");
return RFAILED;
}
ret = WLS_Put(wlsHdlr, WLS_VA2PA(wlsHdlr, currMsg), msgLen, currMsg->msg_type, WLS_SG_FIRST);
if(ret != 0)
{
- DU_LOG("\nFailure in sending message to PHY");
+ DU_LOG("\nERROR --> LWR MAC : Failure in sending message to PHY");
return RFAILED;
}
currMsg = currMsg->p_next;
ret = WLS_Put(wlsHdlr, WLS_VA2PA(wlsHdlr, currMsg), msgLen, currMsg->msg_type, WLS_SG_NEXT);
if(ret != 0)
{
- DU_LOG("\nFailure in sending message to PHY");
+ DU_LOG("\nERROR --> LWR MAC : Failure in sending message to PHY");
return RFAILED;
}
currMsg = currMsg->p_next;
ret = WLS_Put(wlsHdlr, WLS_VA2PA(wlsHdlr, currMsg), msgLen, currMsg->msg_type, WLS_SG_LAST);
if(ret != 0)
{
- DU_LOG("\nFailure in sending message to PHY");
+ DU_LOG("\nERROR --> LWR MAC : Failure in sending message to PHY");
return RFAILED;
}
currMsg = NULLP;
**/
uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm)
{
- printf("\nSending Scheduler config confirm to DU APP");
+ DU_LOG("\nDEBUG --> Sending Scheduler config confirm to DU APP");
pst->dstEnt = ENTDUAPP;
pst->dstInst = 0;
pst->srcInst = 0;
MAC_ALLOC(macCellCb, sizeof(MacCellCb));
if(macCellCb == NULLP)
{
- DU_LOG("\nMAC : macCellCb is NULL at handling of macCellCfg\n");
+ DU_LOG("\nERROR --> MAC : macCellCb is NULL at handling of macCellCfg\n");
return RFAILED;
}
memset(macCellCb, 0, sizeof(MacCellCb));
macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
if(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu == NULLP)
{
- DU_LOG("\nMAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n");
+ DU_LOG("\nERROR --> MAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n");
return RFAILED;
}
memcpy(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1Pdu, \
schedReqCfg->addModListCount = macCellGrp.schReqCfg.addModListCount;
if(schedReqCfg->addModListCount > MAX_NUM_SR_CFG_PER_CELL_GRP)
{
- DU_LOG("\nMAC : Scheduling Request Add/Mod Count %d exceeds max limit %d", \
+ DU_LOG("\nERROR --> MAC : Scheduling Request Add/Mod Count %d exceeds max limit %d", \
schedReqCfg->addModListCount, MAX_NUM_SR_CFG_PER_CELL_GRP);
return RFAILED;
}
tagCfg->addModListCount = macCellGrp.tagCfg.addModListCount;
if(tagCfg->addModListCount > MAX_NUM_TAGS)
{
- DU_LOG("\nMAC : Scheduling Request Add/Mod Count %d exceeds max limit %d", \
+ DU_LOG("\nERROR --> MAC : Scheduling Request Add/Mod Count %d exceeds max limit %d", \
tagCfg->addModListCount, MAX_NUM_TAGS);
return RFAILED;
}
MAC_ALLOC_SHRABL_BUF(schPdschCfg->maxMimoLayers, sizeof(uint8_t));
if(!schPdschCfg->maxMimoLayers)
{
- DU_LOG("\nMAC :Memory Alloc MimoLayers Failed at fillPdschServCellCfg()");
+ DU_LOG("\nERROR --> MAC :Memory Alloc MimoLayers Failed at fillPdschServCellCfg()");
return RFAILED;
}
}
MAC_ALLOC_SHRABL_BUF(schPdschCfg->maxCodeBlkGrpPerTb, sizeof(SchMaxCodeBlkGrpPerTB));
if(!schPdschCfg->maxCodeBlkGrpPerTb)
{
- DU_LOG("\nMAC :Memory Alloc for code Block Failed at fillPdschServCellCfg()");
+ DU_LOG("\nERROR --> MAC :Memory Alloc for code Block Failed at fillPdschServCellCfg()");
return RFAILED;
}
}
MAC_ALLOC_SHRABL_BUF(schPdschCfg->codeBlkGrpFlushInd, sizeof(bool));
if(!schPdschCfg->codeBlkGrpFlushInd)
{
- DU_LOG("\nMAC :Memory Alloc for Flush Ind Failed at fillPdschServCellCfg()");
+ DU_LOG("\nERROR --> MAC :Memory Alloc for Flush Ind Failed at fillPdschServCellCfg()");
return RFAILED;
}
}
MAC_ALLOC_SHRABL_BUF(schPdschCfg->xOverhead, sizeof(SchPdschXOverhead));
if(!schPdschCfg->xOverhead)
{
- DU_LOG("\nMAC :Memory Alloc for xOverHead Failed at fillPdschServCellCfg()");
+ DU_LOG("\nERROR --> MAC :Memory Alloc for xOverHead Failed at fillPdschServCellCfg()");
return RFAILED;
}
}
schPuschCfg->numTimeDomRsrcAlloc = macPuschCfg.numTimeDomRsrcAlloc;
if(schPuschCfg->numTimeDomRsrcAlloc > MAX_NUM_UL_ALLOC)
{
- DU_LOG("\nMAC : Number of Time domain resource allocation [%d] exceeds max limit [%d]",\
+ DU_LOG("\nERROR --> MAC : Number of Time domain resource allocation [%d] exceeds max limit [%d]",\
schPuschCfg->numTimeDomRsrcAlloc, MAX_NUM_UL_ALLOC);
return RFAILED;
}
MAC_ALLOC(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format0, sizeof(SchPucchFormat0));
if(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format0 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory for Format0 in fillResrcList()");
+ DU_LOG("\nERROR --> MAC : Failed to allocate memory for Format0 in fillResrcList()");
return RFAILED;
}
schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format0->initialCyclicShift =\
MAC_ALLOC(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format1, sizeof(SchPucchFormat1));
if(schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format1 == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory for Format1 in fillResrcList()");
+ DU_LOG("\nERROR --> MAC : Failed to allocate memory for Format1 in fillResrcList()");
return RFAILED;
}
schResrcCfg->resrcToAddModList[arrIdx].SchPucchFormat.format1->initialCyclicShift =\
schPdcchCfg->numCRsetToAddMod = macPdcchCfg.numCRsetToAddMod;
if(schPdcchCfg->numCRsetToAddMod > MAX_NUM_CRSET)
{
- DU_LOG("\nMAC : Number of CORESET to ADD/MOD [%d] exceeds max limit [%d]",\
+ DU_LOG("\nERROR --> MAC : Number of CORESET to ADD/MOD [%d] exceeds max limit [%d]",\
schPdcchCfg->numCRsetToAddMod, MAX_NUM_CRSET);
return RFAILED;
}
schPdcchCfg->numCRsetToRel = macPdcchCfg.numCRsetToRel;
if(schPdcchCfg->numCRsetToAddMod > MAX_NUM_CRSET)
{
- DU_LOG("\nMAC : Number of CORESET to release [%d] exceeds max limit [%d]",\
+ DU_LOG("\nERROR --> MAC : Number of CORESET to release [%d] exceeds max limit [%d]",\
schPdcchCfg->numCRsetToRel, MAX_NUM_CRSET);
return RFAILED;
}
schPdcchCfg->numSearchSpcToAddMod = macPdcchCfg.numSearchSpcToAddMod;
if(schPdcchCfg->numSearchSpcToAddMod > MAX_NUM_SEARCH_SPC)
{
- DU_LOG("\nMAC : Number of search space to ADD/MOD [%d] exceeds max [%d]", \
+ DU_LOG("\nERROR --> MAC : Number of search space to ADD/MOD [%d] exceeds max [%d]", \
schPdcchCfg->numSearchSpcToAddMod, MAX_NUM_SEARCH_SPC);
return RFAILED;
}
schPdcchCfg->numSearchSpcToRel = macPdcchCfg.numSearchSpcToRel;
if(schPdcchCfg->numSearchSpcToRel > MAX_NUM_SEARCH_SPC)
{
- DU_LOG("\nMAC : Number of search space to release [%d] exceeds max [%d]", \
+ DU_LOG("\nERROR --> MAC : Number of search space to release [%d] exceeds max [%d]", \
schPdcchCfg->numSearchSpcToRel, MAX_NUM_SEARCH_SPC);
return RFAILED;
}
schPdschCfg->numTimeDomRsrcAlloc = macPdschCfg.numTimeDomRsrcAlloc;
if(schPdschCfg->numTimeDomRsrcAlloc > MAX_NUM_DL_ALLOC)
{
- DU_LOG("\nMAC : Number of time domain resource allocation [%d], exceeds\
+ DU_LOG("\nERROR --> MAC : Number of time domain resource allocation [%d], exceeds\
max limit [%d]", schPdschCfg->numTimeDomRsrcAlloc, MAX_NUM_DL_ALLOC);
return RFAILED;
}
{
if(fillInitDlBwpPdcchCfg(macInitDlBwp.pdcchCfg, &schInitDlBwp->pdcchCfg) != ROK)
{
- DU_LOG("\nMAC : fillInitDlBwpPdcchCfg() failed");
+ DU_LOG("\nERROR --> MAC : fillInitDlBwpPdcchCfg() failed");
return RFAILED;
}
}
{
if(fillInitDlBwpPdschCfg(macInitDlBwp.pdschCfg,&schInitDlBwp->pdschCfg) != ROK)
{
- DU_LOG("\nMAC : fillInitDlBwpPdschCfg() failed");
+ DU_LOG("\nERROR --> MAC : fillInitDlBwpPdschCfg() failed");
return RFAILED;
}
}
if(fillInitialDlBwp(macSpCellCfg.servCellCfg.initDlBwp, \
&servCellCfg->initDlBwp) != ROK )
{
- DU_LOG("\nMAC : fillInitialDlBwp() failed");
+ DU_LOG("\nERROR --> MAC : fillInitialDlBwp() failed");
return RFAILED;
}
servCellCfg->numDlBwpToAdd = macSpCellCfg.servCellCfg.numDlBwpToAdd;
if(servCellCfg->numDlBwpToAdd > MAX_NUM_BWP)
{
- DU_LOG("\nMAC : Number of DL BWP to ADD/MOD [%d] exceeds max limit [%d]",\
+ DU_LOG("\nERROR --> MAC : Number of DL BWP to ADD/MOD [%d] exceeds max limit [%d]",\
servCellCfg->numDlBwpToAdd, MAX_NUM_BWP);
return RFAILED;
}
if(fillPdschServCellCfg(macSpCellCfg.servCellCfg.pdschServCellCfg, \
&servCellCfg->pdschServCellCfg) != ROK)
{
- DU_LOG("\nMAC : fillPdschServCellCfg() failed");
+ DU_LOG("\nERROR --> MAC : fillPdschServCellCfg() failed");
return RFAILED;
}
if(fillInitialUlBwp(macSpCellCfg.servCellCfg.initUlBwp, \
&servCellCfg->initUlBwp) != ROK)
{
- DU_LOG("\nMAC : fillInitialUlBwp() failed");
+ DU_LOG("\nERROR --> MAC : fillInitialUlBwp() failed");
return RFAILED;
}
servCellCfg->numUlBwpToAdd = macSpCellCfg.servCellCfg.numUlBwpToAdd;
if(servCellCfg->numUlBwpToAdd > MAX_NUM_BWP)
{
- DU_LOG("\nMAC : Number of UL BWP to ADD/MOD [%d] exceeds max limit [%d]",\
+ DU_LOG("\nERROR --> MAC : Number of UL BWP to ADD/MOD [%d] exceeds max limit [%d]",\
servCellCfg->numUlBwpToAdd, MAX_NUM_BWP);
return RFAILED;
}
FILL_PST_MAC_TO_SCH(schPst, EVENT_MODIFY_UE_CONFIG_REQ_TO_SCH);
return(*macSchModUeConfigReqOpts[schPst.selector])(&schPst,schUeCfg);
default:
- DU_LOG("\n Invalid Pst received %d", pst->event);
+ DU_LOG("\nERROR --> Invalid Pst received %d", pst->event);
return RFAILED;
}
}
MAC_ALLOC(schLcCfg->drbQos, sizeof(SchDrbQosInfo));
if(!schLcCfg->drbQos)
{
- DU_LOG("\nMAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()");
+ DU_LOG("\nERROR --> MAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()");
ret = RFAILED;
}
}
MAC_ALLOC(schLcCfg->snssai, sizeof(SchSnssai));
if(!schLcCfg->snssai)
{
- DU_LOG("\nMAC : Memory alloc failed at snssai at fillLogicalChannelCfg()");
+ DU_LOG("\nERROR --> MAC : Memory alloc failed at snssai at fillLogicalChannelCfg()");
ret = RFAILED;
}
}
{
if(fillLogicalChannelCfg(&schUeCfg->schLcCfg[lcIdx], &ueCfg->lcCfgList[lcIdx]) != ROK)
{
- DU_LOG("\nMAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx);
+ DU_LOG("\nERROR --> MAC : fillLogicalChannelCfg() failed for lc Idx[%d]", lcIdx);
return RFAILED;
}
schUeCfg->numLcs++;
memset(&schUeCfg->macCellGrpCfg, 0, sizeof(SchMacCellGrpCfg));
if(fillMacCellGroupCfg(ueCfg->macCellGrpCfg, &schUeCfg->macCellGrpCfg) != ROK)
{
- DU_LOG("\nMAC : fillMacCellGroupCfg() failed");
+ DU_LOG("\nERROR --> MAC : fillMacCellGroupCfg() failed");
return RFAILED;
}
memset(&schUeCfg->phyCellGrpCfg, 0,sizeof(SchPhyCellGrpCfg));
if(fillPhyCellGroupCfg(ueCfg->phyCellGrpCfg, &schUeCfg->phyCellGrpCfg) != ROK)
{
- DU_LOG("\nMAC : fillPhyCellGroupCfg() failed");
+ DU_LOG("\nERROR --> MAC : fillPhyCellGroupCfg() failed");
return RFAILED;
}
memset(&schUeCfg->spCellCfg, 0, sizeof(SchSpCellCfg));
if(fillSpCellCfg(ueCfg->spCellCfg, &schUeCfg->spCellCfg) != ROK)
{
- DU_LOG("\nMAC : fillSpCellCfg() failed");
+ DU_LOG("\nERROR --> MAC : fillSpCellCfg() failed");
return RFAILED;
}
MAC_ALLOC(schUeCfg->ambrCfg, sizeof(SchAmbrCfg));
if(!schUeCfg->ambrCfg)
{
- DU_LOG("\nMAC : Memory allocation failed in sendReconfigReqToSch");
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in sendReconfigReqToSch");
return RFAILED;
}
schUeCfg->ambrCfg->ulBr = ueCfg->ambrCfg->ulBr;
ret = fillSchLcCfgList(schUeCfg, ueCfg);
if(ret == RFAILED)
{
- DU_LOG("\nMAC : Failed to copy LCs at fillSchUeCfg()");
+ DU_LOG("\nERROR --> MAC : Failed to copy LCs at fillSchUeCfg()");
return ret;
}
return ret;
/*Nothing to Modify in DL LC CB */
/*Modify UL LC CB */
ueCb->ulInfo.lcCb[ueLcIdx].lcGrpId = ueCfg->lcCfgList[lcIdx].ulLcCfg.lcGroup;
- DU_LOG("\nMAC: Successfully Modified LC context for lcId[%d]", ueCfg->lcCfgList[lcIdx].lcId);
+ DU_LOG("\nINFO --> MAC: Successfully Modified LC context for lcId[%d]", ueCfg->lcCfgList[lcIdx].lcId);
break;
}
if(ueCfg->lcCfgList[lcIdx].configType == CONFIG_DEL)
memset(&ueCb->ulInfo.lcCb[ueLcIdx], 0, sizeof(UlLcCb));
(ueCb->ulInfo.numUlLc)--;
updateMacUlCb(ueLcIdx, &ueCb->ulInfo);
- DU_LOG("\nMAC: Successfully Deleted LC context for lcId[%d]", ueCfg->lcCfgList[lcIdx].lcId);
+ DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", ueCfg->lcCfgList[lcIdx].lcId);
break;
}
}
ret = fillMacLcCfgList(ueCb, ueCfg);
if(ret == RFAILED)
{
- DU_LOG("\nMAC: Failed while filing MAC LC List at fillMacUeCb()");
+ DU_LOG("\nERROR --> MAC: Failed while filing MAC LC List at fillMacUeCb()");
}
return ret;
}
if((ueCb->ueIdx == ueCfg->ueIdx) && (ueCb->crnti == ueCfg->crnti)\
&&(ueCb->state == UE_STATE_ACTIVE))
{
- DU_LOG("\n MAC : CRNTI %d already configured ", ueCfg->crnti);
+ DU_LOG("\nERROR --> MAC : CRNTI %d already configured ", ueCfg->crnti);
return ROKDUP;
}
else
ret = fillMacUeCb(ueCb, ueCfg, cellIdx);
if(ret != ROK)
{
- DU_LOG("\nMAC : Failed to create Ue Cb at createUeCb()");
+ DU_LOG("\nERROR --> MAC : Failed to create Ue Cb at createUeCb()");
return ret;
}
else
if((ueCb->ueIdx == ueCfg->ueIdx) && (ueCb->crnti == ueCfg->crnti)\
&&(ueCb->state == UE_STATE_ACTIVE))
{
- DU_LOG("\n MAC : Modifying Ue config Req for CRNTI %d ", ueCfg->crnti);
+ DU_LOG("\nINFO --> MAC : Modifying Ue config Req for CRNTI %d ", ueCfg->crnti);
ret = fillMacUeCb(ueCb, ueCfg, cellIdx);
if(ret != ROK)
{
- DU_LOG("\nMAC : Failed to modify MacUeCb at modifyUeCb()");
+ DU_LOG("\nERROR --> MAC : Failed to modify MacUeCb at modifyUeCb()");
return ret;
}
else
/* Validate cell id */
if(macCb.macCell[cellIdx]->cellId != ueCfg->cellId)
{
- DU_LOG("\nMAC : Cell Id %d not configured", ueCfg->cellId);
+ DU_LOG("\nERROR --> MAC : Cell Id %d not configured", ueCfg->cellId);
return RFAILED;
}
/* Check if max number of UE configured */
if(macCb.macCell[cellIdx]->numActvUe > MAX_NUM_UE)
{
- DU_LOG("MAC : Max number of UE [%d] already configured", MAX_NUM_UE);
+ DU_LOG("\nERROR --> MAC : Max number of UE [%d] already configured", MAX_NUM_UE);
return RFAILED;
}
case EVENT_UE_CONFIG_RSP_TO_MAC:
ret = createUeCb(cellIdx, ueCb, ueCfg);
if(ret != ROK)
- DU_LOG("\nMAC: AddUeConfigReq for cellIdx :%d failed in procMacUeCfgData()", cellIdx);
+ DU_LOG("\nERROR --> MAC: AddUeConfigReq for cellIdx :%d failed in procMacUeCfgData()", cellIdx);
break;
case EVENT_UE_RECONFIG_RSP_TO_MAC:
ret = modifyUeCb(cellIdx, ueCb, ueCfg);
if(ret != ROK)
- DU_LOG("\nMAC: ModifyUeConfigReq for cellIdx :%d failed at procMacUeCfgData()", cellIdx);
+ DU_LOG("\nERROR --> MAC: ModifyUeConfigReq for cellIdx :%d failed at procMacUeCfgData()", cellIdx);
break;
default:
break;
MAC_ALLOC(tmpData, sizeof(MacUeCfg));
if(!tmpData)
{
- DU_LOG("\nMAC: Memory Alloc Failed at copyToTmpData()");
+ DU_LOG("\nERROR --> MAC: Memory Alloc Failed at copyToTmpData()");
return RFAILED;
}
memcpy(tmpData, ueCfg, sizeof(MacUeCfg));
SchUeCfg schUeCfg;
memset(&schUeCfg, 0, sizeof(SchUeCfg));
- DU_LOG("\nMAC : UE Create Request for CRNTI[%d]", ueCfg->crnti);
+ DU_LOG("\nINFO --> MAC : UE Create Request for CRNTI[%d]", ueCfg->crnti);
if(ueCfg)
{
/*Sending Cfg Req to SCH */
ret = fillSchUeCfg(pst, &schUeCfg, ueCfg);
if(ret != ROK)
- DU_LOG("\nMAC : Failed to fill Sch Ue Cfg at MacProcUeCreateReq()");
+ DU_LOG("\nERROR --> MAC : Failed to fill Sch Ue Cfg at MacProcUeCreateReq()");
else
{
/* Fill event and send UE create request to SCH */
ret = sendUeReqToSch(pst, &schUeCfg);
if(ret != ROK)
- DU_LOG("\nMAC : Failed to send UE Create request to SCH");
+ DU_LOG("\nERROR --> MAC : Failed to send UE Create request to SCH");
}
}
else
{
- DU_LOG("\nMAC : Failed to store MAC UE CFG ");
+ DU_LOG("\nERROR --> MAC : Failed to store MAC UE CFG ");
}
}
else
{
- DU_LOG("\nMAC : MAC UE Create request processing failed");
+ DU_LOG("\nERROR --> MAC : MAC UE Create request processing failed");
ret = RFAILED;
}
/* FREE shared memory */
MAC_ALLOC_SHRABL_BUF(cfgRsp, sizeof(MacUeCfgRsp));
if(!cfgRsp)
{
- DU_LOG("\nMAC: Memory allocation for UE config response failed");
+ DU_LOG("\nERROR --> MAC: Memory allocation for UE config response failed");
return RFAILED;
}
MAC_ALLOC_SHRABL_BUF(cfgRsp, sizeof(MacUeCfgRsp));
if(!cfgRsp)
{
- DU_LOG("\nMAC: Memory allocation for UE Reconfig response failed");
+ DU_LOG("\nERROR --> MAC: Memory allocation for UE Reconfig response failed");
return RFAILED;
}
}
else
{
- DU_LOG("\nMAC: Failed to get macCellCb in getMacUeCfg()");
+ DU_LOG("\nERROR --> MAC: Failed to get macCellCb in getMacUeCfg()");
}
return ueCfg;
}
ueCfg = getMacUeCfg(cellIdx, schCfgRsp->ueIdx);
if(ueCfg == NULLP)
{
- DU_LOG("\nMAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event);
+ DU_LOG("\nERROR --> MAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event);
ret = RFAILED;
}
{
if(schCfgRsp->rsp != RSP_NOK)
{
- DU_LOG("\nMAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ DU_LOG("\nINFO --> MAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
if(ret == ROK)
{
ret = procMacUeCfgData(pst, ueCfg);
}
else
{
- DU_LOG("\nMAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ DU_LOG("\nERROR --> MAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
}
ret = MacSendUeCreateRsp(result, schCfgRsp);
}
{
if(schCfgRsp->rsp != RSP_NOK)
{
- DU_LOG("\nMAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ DU_LOG("\nINFO --> MAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
if(ret == ROK)
{
ret = procMacUeCfgData(pst, ueCfg);
}
else
{
- DU_LOG("\nMAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ DU_LOG("\nERROR --> MAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
}
ret = MacSendUeReconfigRsp(result, schCfgRsp);
}
SchUeCfg schUeCfg;
memset(&schUeCfg, 0, sizeof(SchUeCfg));
- DU_LOG("\nMAC : UE Reconfig Request for CRNTI[%d]", ueCfg->crnti);
+ DU_LOG("\nINFO --> MAC : UE Reconfig Request for CRNTI[%d]", ueCfg->crnti);
if(ueCfg)
{
/*Sending Cfg Req to SCH */
ret = fillSchUeCfg(pst, &schUeCfg, ueCfg);
if(ret != ROK)
- DU_LOG("\nMAC : Failed to fill sch Ue Cfg at MacProcUeReconfigReq()");
+ DU_LOG("\nERROR --> MAC : Failed to fill sch Ue Cfg at MacProcUeReconfigReq()");
else
{
/* Fill event and send UE create request to SCH */
ret = sendUeReqToSch(pst, &schUeCfg);
if(ret != ROK)
- DU_LOG("\nMAC : Failed to send UE Reconfig Request to SCH");
+ DU_LOG("\nERROR --> MAC : Failed to send UE Reconfig Request to SCH");
}
}
else
{
- DU_LOG("\nMAC : Failed to store MAC UE Cb ");
+ DU_LOG("\nERROR --> MAC : Failed to store MAC UE Cb ");
}
}
else
{
- DU_LOG("\nMAC : MAC UE Create request processing failed");
+ DU_LOG("\nERROR --> MAC : MAC UE Create request processing failed");
ret = RFAILED;
}
/* FREE shared memory */