packMacSchModUeConfigReq /* packing for light weight loosely coupled */
};
+MacSchUeDeleteReqFunc macSchUeDeleteReqOpts[] =
+{
+ packMacSchUeDeleteReq, /* packing for loosely coupled */
+ MacSchUeDeleteReq, /* packing for tightly coupled */
+ packMacSchUeDeleteReq /* packing for light weight loosely coupled */
+};
+
+MacDuUeDeleteRspFunc macDuUeDeleteRspOpts[] =
+{
+ packDuMacUeDeleteRsp, /* packing for loosely coupled */
+ DuProcMacUeDeleteRsp, /* packing for tightly coupled */
+ packDuMacUeDeleteRsp /* packing for light weight loosly coupled */
+};
+
+MacSchCellDeleteReqFunc macSchCellDeleteReqOpts[]=
+{
+ packMacSchCellDeleteReq, /* packing for loosely coupled */
+ MacSchCellDeleteReq, /* packing for tightly coupled */
+ packMacSchCellDeleteReq /* packing for light weight loosely coupled */
+};
+
+MacDuCellDeleteRspFunc macDuCellDeleteRspOpts[] =
+{
+ packDuMacCellDeleteRsp, /* packing for loosely coupled */
+ DuProcMacCellDeleteRsp, /* packing for tightly coupled */
+ packDuMacCellDeleteRsp /* packing for light weight loosly coupled */
+};
+
/*******************************************************************
*
* @brief Fills mac cell group config to be sent to scheduler
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++;
schUeCfg->crnti = ueCfg->crnti;
/* Copy MAC cell group config */
- memset(&schUeCfg->macCellGrpCfg, 0, sizeof(SchMacCellGrpCfg));
- if(fillMacCellGroupCfg(ueCfg->macCellGrpCfg, &schUeCfg->macCellGrpCfg) != ROK)
+ if(ueCfg->macCellGrpCfgPres == true)
{
- DU_LOG("\nMAC : fillMacCellGroupCfg() failed");
- return RFAILED;
+ schUeCfg->macCellGrpCfgPres = true;
+ memset(&schUeCfg->macCellGrpCfg, 0, sizeof(SchMacCellGrpCfg));
+ if(fillMacCellGroupCfg(ueCfg->macCellGrpCfg, &schUeCfg->macCellGrpCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillMacCellGroupCfg() failed");
+ return RFAILED;
+ }
}
-
- /* Copy Physical cell group config */
- memset(&schUeCfg->phyCellGrpCfg, 0,sizeof(SchPhyCellGrpCfg));
- if(fillPhyCellGroupCfg(ueCfg->phyCellGrpCfg, &schUeCfg->phyCellGrpCfg) != ROK)
+ if(ueCfg->phyCellGrpCfgPres == true)
{
- DU_LOG("\nMAC : fillPhyCellGroupCfg() failed");
- return RFAILED;
+ schUeCfg->phyCellGrpCfgPres = true;
+ /* Copy Physical cell group config */
+ memset(&schUeCfg->phyCellGrpCfg, 0,sizeof(SchPhyCellGrpCfg));
+ if(fillPhyCellGroupCfg(ueCfg->phyCellGrpCfg, &schUeCfg->phyCellGrpCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillPhyCellGroupCfg() failed");
+ return RFAILED;
+ }
}
- /* Copy sp cell config */
- memset(&schUeCfg->spCellCfg, 0, sizeof(SchSpCellCfg));
- if(fillSpCellCfg(ueCfg->spCellCfg, &schUeCfg->spCellCfg) != ROK)
+ if(ueCfg->spCellCfgPres == true)
{
- DU_LOG("\nMAC : fillSpCellCfg() failed");
- return RFAILED;
+ schUeCfg->spCellCfgPres = true;
+ /* Copy sp cell config */
+ memset(&schUeCfg->spCellCfg, 0, sizeof(SchSpCellCfg));
+ if(fillSpCellCfg(ueCfg->spCellCfg, &schUeCfg->spCellCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : fillSpCellCfg() failed");
+ return RFAILED;
+ }
}
-
if(ueCfg->ambrCfg != NULLP)
{
MAC_ALLOC(schUeCfg->ambrCfg, sizeof(SchAmbrCfg));
if(!schUeCfg->ambrCfg)
{
- DU_LOG("\nMAC : Memory allocation failed in sendReconfigReqToSch");
- return RFAILED;
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in sendReconfigReqToSch");
+ return RFAILED;
}
schUeCfg->ambrCfg->ulBr = ueCfg->ambrCfg->ulBr;
- schUeCfg->ambrCfg->dlBr = ueCfg->ambrCfg->dlBr;
}
else
schUeCfg->ambrCfg = NULLP;
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;
}
}
ueCb->ueIdx = ueCfg->ueIdx;
ueCb->crnti = ueCfg->crnti;
ueCb->cellCb = macCb.macCell[cellIdx];
- ueCb->dlInfo.dlHarqEnt.numHarqProcs = \
+ if(ueCfg->spCellCfgPres)
+ {
+ ueCb->dlInfo.dlHarqEnt.numHarqProcs = \
ueCfg->spCellCfg.servCellCfg.pdschServCellCfg.numHarqProcForPdsch;
+ }
ueCb->state = UE_STATE_ACTIVE;
/*TODO: To check the bsr value during implementation */
- ueCb->bsrTmrCfg.periodicTimer = ueCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer;
- ueCb->bsrTmrCfg.retxTimer = ueCfg->macCellGrpCfg.bsrTmrCfg.retxTimer;
- ueCb->bsrTmrCfg.srDelayTimer = ueCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer;
+ if(ueCfg->macCellGrpCfgPres)
+ {
+ ueCb->bsrTmrCfg.periodicTimer = ueCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer;
+ ueCb->bsrTmrCfg.retxTimer = ueCfg->macCellGrpCfg.bsrTmrCfg.retxTimer;
+ ueCb->bsrTmrCfg.srDelayTimer = ueCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer;
+ }
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)
{
if(ret == ROK)
{
/*Sending Cfg Req to SCH */
- ret = fillSchUeCfg(pst, &schUeCfg, ueCfg);
- if(ret != ROK)
- DU_LOG("\nMAC : Failed to fill sch Ue Cfg at MacProcUeReconfigReq()");
+ ret = fillSchUeCfg(pst, &schUeCfg, ueCfg);
+ if(ret != ROK)
+ 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");
- }
+ if(ret != ROK)
+ 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 */
return ROK;
}
+/*******************************************************************
+*
+* @brief Fill and Send UE Delete response from MAC to DU APP
+*
+* @details
+*
+* Function : MacSendUeDeleteRsp
+*
+* Functionality: Fill and Send UE Delete response from MAC to DUAPP
+*
+* @params[in] MAC UE delete result
+* SCH UE delete response
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+
+uint8_t MacSendUeDeleteRsp(uint16_t cellId, uint16_t crnti, UeDeleteStatus result)
+{
+ MacUeDeleteRsp *deleteRsp;
+ Pst rspPst;
+
+ MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacUeDeleteRsp));
+ if(!deleteRsp)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation for UE delete response failed");
+ return RFAILED;
+ }
+
+ /* Filling UE delete response */
+ deleteRsp->cellId = cellId;
+ GET_UE_IDX(crnti,deleteRsp->ueIdx);
+ deleteRsp->result = result;
+
+ /* Fill Post structure and send UE delete response*/
+ memset(&rspPst, 0, sizeof(Pst));
+ FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_UE_DELETE_RSP);
+ return (*macDuUeDeleteRspOpts[rspPst.selector])(&rspPst, deleteRsp);
+}
+
+/*******************************************************************
+*
+* @brief freeing the Pucch Resrc Cfg
+*
+* @details
+*
+* Function : deletePucchResourcesCfg
+*
+* Functionality: freeing the Pucch Resrc Cfg
+*
+* @params[in] PucchResrcCfg *resrcCfg
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+
+void deletePucchResourcesCfg(PucchResrcCfg *resrcCfg)
+{
+ uint8_t resrcIdx;
+ for(resrcIdx =0; resrcIdx< resrcCfg->resrcToAddModListCount;resrcIdx++)
+ {
+ switch(resrcCfg->resrcToAddModList[resrcIdx].pucchFormat)
+ {
+ case PUCCH_FORMAT_0:
+ {
+ MAC_FREE(resrcCfg->resrcToAddModList[resrcIdx].PucchFormat.format0, sizeof(PucchFormat0));
+ break;
+ }
+ case PUCCH_FORMAT_1:
+ {
+ MAC_FREE(resrcCfg->resrcToAddModList[resrcIdx].PucchFormat.format1, sizeof(PucchFormat1));
+ break;
+ }
+ case PUCCH_FORMAT_2:
+ {
+ MAC_FREE(resrcCfg->resrcToAddModList[resrcIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
+ break;
+ }
+ case PUCCH_FORMAT_3:
+ {
+ MAC_FREE(resrcCfg->resrcToAddModList[resrcIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
+ break;
+ }
+ case PUCCH_FORMAT_4:
+ {
+ MAC_FREE(resrcCfg->resrcToAddModList[resrcIdx].PucchFormat.format4, sizeof(PucchFormat4));
+ break;
+ }
+ }
+ }
+
+}
+
+/*******************************************************************
+*
+* @brief Function to delete MAC Pdsch ServCellCfg
+*
+* @details
+*
+* Function : deleteMacPdschServCellCfg
+*
+* Functionality: Function to delete MAC Pdsch ServCellCfg
+*
+* @params[in] PdschServCellCfg *pdschServCellCfg
+* @return void
+*
+* ****************************************************************/
+
+void deleteMacPdschServCellCfg(PdschServCellCfg *pdschServCellCfg)
+{
+ MAC_FREE(pdschServCellCfg->maxMimoLayers, sizeof(uint8_t));
+ MAC_FREE(pdschServCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
+ MAC_FREE(pdschServCellCfg->codeBlkGrpFlushInd, sizeof(bool));
+ MAC_FREE(pdschServCellCfg->xOverhead, sizeof(PdschXOverhead));
+}
+
+/*******************************************************************
+*
+* @brief Handles UE Delete requst from DU APP
+*
+* @details
+*
+* Function : deleteMacUeCb
+*
+* Functionality: Handles UE Delete requst from DU APP
+*
+* @params[in] MacCellCb *cellCb,uint16_t ueIdx
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+
+void deleteMacUeCb(MacUeCb *ueCb)
+{
+ MacUeCfg *ueCfg = NULLP;
+ ServCellCfgInfo *servCellCfg;
+
+ if(ueCb->cellCb)
+ {
+ MAC_FREE(ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4Pdu, ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4PduLen);
+ MAC_FREE(ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4TxPdu, ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4TbSize);
+
+ if(ueCb->cellCb->ueCfgTmpData[ueCb->ueIdx-1])
+ {
+ ueCfg =ueCb->cellCb->ueCfgTmpData[ueCb->ueIdx-1];
+ MAC_FREE(ueCfg->ambrCfg, sizeof(AmbrCfg));
+ if(ueCfg->spCellCfgPres)
+ {
+ servCellCfg = &ueCfg->spCellCfg.servCellCfg;
+ MAC_FREE(servCellCfg->bwpInactivityTmr, sizeof(uint8_t));
+
+ if(servCellCfg->initUlBwp.pucchPresent)
+ {
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.resrcSet, sizeof(PucchResrcSetCfg));
+
+ if(servCellCfg->initUlBwp.pucchCfg.resrc)
+ {
+ deletePucchResourcesCfg(servCellCfg->initUlBwp.pucchCfg.resrc);
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.resrc, sizeof(PucchResrcCfg));
+ }
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format1, sizeof(PucchFormatCfg));
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format2, sizeof(PucchFormatCfg));
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format3, sizeof(PucchFormatCfg));
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format4, sizeof(PucchFormatCfg));
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.schedReq, sizeof(PucchSchedReqCfg));
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.multiCsiCfg, sizeof(PucchMultiCsiCfg));
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.spatialInfo, sizeof(PucchSpatialCfg));
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.dlDataToUlAck , sizeof(PucchDlDataToUlAck));
+ MAC_FREE(servCellCfg->initUlBwp.pucchCfg.powerControl, sizeof(PucchPowerControl));
+ deleteMacPdschServCellCfg(&servCellCfg->pdschServCellCfg);
+ }
+ }
+ for(uint8_t idx=0 ;idx < ueCfg->numLcs; idx++)
+ {
+ MAC_FREE(ueCfg->lcCfgList[idx].drbQos, sizeof(DrbQosInfo));
+ MAC_FREE(ueCfg->lcCfgList[idx].snssai, sizeof(Snssai));
+ }
+ MAC_FREE(ueCb->cellCb->ueCfgTmpData[ueCb->ueIdx-1],sizeof(MacUeCfg));
+ }
+ }
+ memset(ueCb, 0, sizeof(MacUeCb));
+}
+
+/*******************************************************************
+*
+* @brief Processes UE delete response from scheduler
+*
+* @details
+*
+* Function : MacProcSchUeCfgRsp
+*
+* Functionality:
+* Processes UE create delete from scheduler
+*
+* @params[in] Pst : Post structure
+* schUeDelRsp : Scheduler UE delete respons
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+
+uint8_t MacProcSchUeDeleteRsp(Pst *pst, SchUeDeleteRsp *schUeDelRsp)
+{
+ uint8_t ueIdx =0;
+ uint16_t cellIdx=0;
+ uint8_t ret = RFAILED;
+ UeDeleteStatus result;
+
+ if(schUeDelRsp)
+ {
+ if(schUeDelRsp->rsp == RSP_OK)
+ {
+ DU_LOG("\nINFO --> MAC : SCH UE Delete response for CRNTI[%d] is successful", schUeDelRsp->crnti);
+ GET_CELL_IDX(schUeDelRsp->cellId, cellIdx);
+ if(macCb.macCell[cellIdx])
+ {
+ GET_UE_IDX(schUeDelRsp->crnti, ueIdx);
+ if(macCb.macCell[cellIdx]->ueCb[ueIdx -1].crnti == schUeDelRsp->crnti)
+ {
+ deleteMacUeCb(&macCb.macCell[cellIdx]->ueCb[ueIdx -1]);
+ macCb.macCell[cellIdx]->numActvUe--;
+ result = SUCCESS;
+ ret = ROK;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): crnti[%d] does not exist ",schUeDelRsp->crnti);
+ result = UEIDX_INVALID;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): cellId[%d] does not exist ",schUeDelRsp->cellId);
+ result = CELLID_INVALID;
+ }
+ }
+ else
+ {
+ result = (schUeDelRsp->cause == INVALID_CELLID) ? CELLID_INVALID : UEIDX_INVALID;
+ }
+ if(MacSendUeDeleteRsp(schUeDelRsp->cellId, schUeDelRsp->crnti, result) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC: MacProcSchUeDeleteRsp(): Failed to send UE delete response");
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC: MacProcSchUeDeleteRsp(): Failed to receive UE delete response by SCH");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+/*******************************************************************
+*
+* @brief Sends UE delete req to Scheduler
+*
+* @details
+*
+* Function : sendUeDelReqToSch
+*
+* Functionality: sends UE delete req to Scheduler
+*
+* @params[in] Pst *pst, MacUeDelete *ueDelete
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+
+uint8_t sendUeDelReqToSch(Pst *pst, MacUeDelete *ueDelete)
+{
+ if(ueDelete != NULLP)
+ {
+ Pst schPst;
+ SchUeDelete schUeDel;
+
+ memset(&schUeDel, 0, sizeof(SchUeDelete));
+ schUeDel.cellId = ueDelete->cellId;
+ schUeDel.crnti = ueDelete->crnti;
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, ueDelete, sizeof(MacUeDelete));
+ FILL_PST_MAC_TO_SCH(schPst, EVENT_UE_DELETE_REQ_TO_SCH);
+ return(*macSchUeDeleteReqOpts[schPst.selector])(&schPst, &schUeDel);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> SCH: sendUeDelReqToSch():MAC Ue Delete is NULL");
+ return RFAILED;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Handles UE Delete requst from DU APP
+ *
+ * @details
+ *
+ * Function : MacProcUeDeleteReq
+ *
+ * Functionality: Handles UE Delete requst from DU APP
+ *
+ * @params[in] Pst *pst, MacUeDelete *ueDelete
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t MacProcUeDeleteReq(Pst *pst, MacUeDelete *ueDelete)
+{
+ uint8_t ret = ROK;
+ uint8_t cellIdx=0;
+ UeDeleteStatus result=SUCCESS;
+ MacUeCb *ueCb = NULLP;
+ MacCellCb *cellCb = NULLP;
+
+ DU_LOG("\nINFO --> MAC : UE Delete Request received for ueIdx[%d]", ueDelete->ueIdx);
+
+ if(ueDelete)
+ {
+ GET_CELL_IDX(ueDelete->cellId, cellIdx);
+ cellCb = macCb.macCell[cellIdx];
+ if(cellCb)
+ {
+ ueCb = &cellCb->ueCb[ueDelete->ueIdx-1];
+ if(ueCb->crnti == ueDelete->crnti)
+ {
+ ret = sendUeDelReqToSch(pst, ueDelete);
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): Failed to send UE Delete Request to SCH");
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): CRNTI is not matched");
+ result = UEIDX_INVALID;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): Failed to find the MacUeCb of UeIdx = %d",ueDelete->ueIdx);
+ result = CELLID_INVALID;
+ }
+
+ if(result != SUCCESS)
+ {
+ MacSendUeDeleteRsp(ueDelete->cellId, ueDelete->crnti, result);
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, ueDelete, sizeof(MacUeDelete));
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): MAC UE delete request processing failed");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill and Send Cell Delete response from MAC to DU APP
+ *
+ * @details
+ *
+ * Function : MacSendCellDeleteRsp
+ *
+ * Functionality: Fill and Send Cell Delete response from MAC to DUAPP
+ *
+ * @params[in] MAC Cell delete result
+ * SCH Cell delete response
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t MacSendCellDeleteRsp(CellDeleteStatus result, uint8_t cellId)
+{
+ MacCellDeleteRsp *deleteRsp=NULLP;
+ Pst rspPst;
+
+ MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacCellDeleteRsp));
+ if(!deleteRsp)
+ {
+ DU_LOG("\nERROR --> MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed");
+ return RFAILED;
+ }
+
+ /* Filling CELL delete response */
+ deleteRsp->cellId = cellId;
+ deleteRsp->result = result;
+
+ /* Fill Post structure and send CELL delete response*/
+ memset(&rspPst, 0, sizeof(Pst));
+ FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_CELL_DELETE_RSP);
+ return (*macDuCellDeleteRspOpts[rspPst.selector])(&rspPst, deleteRsp);
+}
+
+/*******************************************************************
+ *
+ * @brief delete MAC CellCb information
+ *
+ * @details
+ *
+ * Function : deleteMacCellCb
+ *
+ * Functionality:
+ * delete MAC CellCb information
+ *
+ * @params[in] MacCellCb * cellCb
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void deleteMacCellCb(MacCellCb * cellCb)
+{
+ uint8_t idx;
+ for(idx=0; idx<MAX_SLOTS; idx++)
+ {
+ MAC_FREE(cellCb->dlSlot[idx].dlInfo.rarAlloc, sizeof(RarAlloc));
+ if(cellCb->dlSlot[idx].dlInfo.ulGrant)
+ {
+ MAC_FREE(cellCb->dlSlot[idx].dlInfo.ulGrant->dciInfo.pdschCfg, sizeof(PdschCfg));
+ MAC_FREE(cellCb->dlSlot[idx].dlInfo.ulGrant, sizeof(DciInfo));
+ }
+ if(cellCb->dlSlot[idx].dlInfo.dlMsgAlloc)
+ {
+ MAC_FREE(cellCb->dlSlot[idx].dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPdu,\
+ cellCb->dlSlot[idx].dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPduLen);
+ MAC_FREE(cellCb->dlSlot[idx].dlInfo.dlMsgAlloc, sizeof(DlMsgAlloc));
+ }
+ }
+
+ memset(cellCb, 0, sizeof(MacCellCb));
+}
+
+/*******************************************************************
+ *
+ * @brief Processes CELL delete response from scheduler
+ *
+ * @details
+ *
+ * Function : MacProcSchCellDeleteRsp
+ *
+ * Functionality:
+ * Processes CELL delete from scheduler
+ *
+ * @params[in] Pst : Post structure
+ * schCellDelRsp : Scheduler CELL delete respons
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * * ****************************************************************/
+uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp)
+{
+ uint8_t ret = ROK;
+ uint16_t cellIdx=0;
+ CellDeleteStatus status;
+
+ if(schCellDelRsp)
+ {
+ if(schCellDelRsp->rsp == RSP_OK)
+ {
+ DU_LOG("\nINFO --> MAC : SCH CELL Delete response for cellId[%d] is successful ", \
+ schCellDelRsp->cellId);
+ GET_CELL_IDX(schCellDelRsp->cellId, cellIdx);
+ if(macCb.macCell[cellIdx])
+ {
+ if(macCb.macCell[cellIdx]->cellId == schCellDelRsp->cellId)
+ {
+ deleteMacCellCb(macCb.macCell[cellIdx]);
+ status = SUCCESSFUL_RSP;
+ MAC_FREE(macCb.macCell[cellIdx], sizeof(MacCellCb));
+ }
+ else
+ {
+ DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
+ status = CELL_ID_INVALID;
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
+ status = CELL_ID_INVALID;
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
+ status = CELL_ID_INVALID;
+ ret = RFAILED;
+ }
+ if(MacSendCellDeleteRsp(status, schCellDelRsp->cellId) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response");
+ ret = RFAILED;
+ }
+
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC: MacProcSchCellDeleteRsp(): schCellDelRsp is NULL");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Sends Cell delete req to Scheduler
+ *
+ * @details
+ *
+ * Function : sendCellDelReqToSch
+ *
+ * Functionality: sends Cell delete req to Scheduler
+ *
+ * @params[in] SchCellDelete *schCellDel
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t sendCellDelReqToSch(SchCellDelete *schCellDel)
+{
+ Pst schPst;
+ FILL_PST_MAC_TO_SCH(schPst, EVENT_CELL_DELETE_REQ_TO_SCH);
+ return(*macSchCellDeleteReqOpts[schPst.selector])(&schPst, schCellDel);
+}
+
+/*******************************************************************
+ *
+ * @brief Handles CELL Delete requst from DU APP
+ *
+ * @details
+ *
+ * Function : MacProcCellDeleteReq
+ *
+ * Functionality: Handles CELL Delete requst from DU APP
+ *
+ * @params[in] Pst *pst, MacCellDelete *cellDelete
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *
+ * ****************************************************************/
+uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDelete *cellDelete)
+{
+ uint8_t ret = ROK, cellIdx=0;
+ SchCellDelete schCellDelete;
+
+ DU_LOG("\nINFO --> MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId);
+
+ if(cellDelete)
+ {
+ GET_CELL_IDX(cellDelete->cellId, cellIdx);
+ if(macCb.macCell[cellIdx])
+ {
+ if(macCb.macCell[cellIdx]->cellId == cellDelete->cellId)
+ {
+ memset(&schCellDelete, 0, sizeof(SchCellDelete));
+ schCellDelete.cellId = cellDelete->cellId;
+ ret = sendCellDelReqToSch(&schCellDelete);
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to send UE Delete Request to SCH");
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
+ cellDelete->cellId);
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
+ cellDelete->cellId);
+ ret = RFAILED;
+ }
+
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Sending failure response to DU");
+ if(MacSendCellDeleteRsp(CELL_ID_INVALID, cellDelete->cellId) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\
+ cellDelete->cellId);
+ }
+
+ }
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellDelete, sizeof(MacCellDelete));
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL");
+ ret = RFAILED;
+ }
+ return ret;
+}
/**********************************************************************
End of file
Code Review / o-du / l2.git / blobdiff