packSchCellCfg /* 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 */
+};
+
+MacDuSliceCfgRspFunc macDuSliceCfgRspOpts[] =
+{
+ packDuMacSliceCfgRsp, /* packing for loosely coupled */
+ DuProcMacSliceCfgRsp, /* packing for tightly coupled */
+ packDuMacSliceCfgRsp /* packing for light weight loosly coupled */
+};
+
+MacDuSliceReCfgRspFunc macDuSliceReCfgRspOpts[] =
+{
+ packDuMacSliceReCfgRsp, /* packing for loosely coupled */
+ DuProcMacSliceReCfgRsp, /* packing for tightly coupled */
+ packDuMacSliceReCfgRsp /* packing for light weight loosly coupled */
+};
/**
* @brief Layer Manager Configuration request handler for Scheduler
**/
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;
{
Pst cfmPst;
uint16_t cellIdx;
- uint8_t ret = ROK;
+ uint8_t ret = ROK, sliceIdx = 0;
MacCellCb *macCellCb;
memset((uint8_t *)&cfmPst, 0, sizeof(Pst));
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, \
macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
+
+ macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice = macCellCfg->plmnInfoList.numSupportedSlice;
+ MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice\
+ * sizeof(Snssai*));
+ if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC: Memory allocation failed at MacProcCellCfgReq");
+ return RFAILED;
+ }
+
+ if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai)
+ {
+ for(sliceIdx=0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++)
+ {
+ if(macCellCfg->plmnInfoList.snssai[sliceIdx])
+ {
+ MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
+ if(!macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx])
+ {
+ DU_LOG("\nERROR --> MAC: Memory allocation failed at MacProcCellCfgReq");
+ return RFAILED;
+ }
+ memcpy(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx],\
+ sizeof(Snssai));
+ }
+ }
+ }
/* Send cell cfg to scheduler */
ret = MacSchCellCfgReq(pst, macCellCfg);
}
else
{
- if(macCellCfg->prachCfg.fdm[0].numUnusedRootSeq != 0)
- {
- MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg->prachCfg.fdm[0].unsuedRootSeq,
- macCellCfg->prachCfg.fdm[0].numUnusedRootSeq* sizeof(uint8_t));
- }
- MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg->sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1PduLen);
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg ,sizeof(MacCellCfg));
}
return ret;
{
SchCellCfg schCellCfg;
Pst cfgPst;
- uint8_t ret;
+ uint8_t ssbMaskIdx = 0, rsrcListIdx = 0, ret=0, sliceIdx=0;
memset(&cfgPst, 0, sizeof(Pst));
+ memset(&schCellCfg, 0, sizeof(SchCellCfg));
schCellCfg.cellId = macCellCfg->cellId;
schCellCfg.phyCellId = macCellCfg->phyCellId;
- schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw;
schCellCfg.numerology = macCellCfg->numerology;
schCellCfg.dupMode = macCellCfg->dupType;
+ schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw;
+ schCellCfg.dlFreq = macCellCfg->dlCarrCfg.freq;
+ schCellCfg.ulFreq = macCellCfg->ulCarrCfg.freq;
/* fill ssb scheduler parameters */
schCellCfg.ssbSchCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr;
schCellCfg.ssbSchCfg.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
schCellCfg.ssbSchCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod];
schCellCfg.ssbSchCfg.ssbSubcOffset = macCellCfg->ssbCfg.ssbScOffset;
- for(uint8_t idx=0; idx<SSB_MASK_SIZE; idx++)
+ for(ssbMaskIdx=0; ssbMaskIdx<SSB_MASK_SIZE; ssbMaskIdx++)
{
- schCellCfg.ssbSchCfg.nSSBMask[idx] = macCellCfg->ssbCfg.ssbMask[idx];
+ schCellCfg.ssbSchCfg.nSSBMask[ssbMaskIdx] = macCellCfg->ssbCfg.ssbMask[ssbMaskIdx];
}
+ schCellCfg.ssbSchCfg.totNumSsb = countSetBits(schCellCfg.ssbSchCfg.nSSBMask[0]);
/* fill SIB1 scheduler parameters */
schCellCfg.sib1SchCfg.sib1PduLen = macCellCfg->sib1Cfg.sib1PduLen;
- schCellCfg.sib1SchCfg.sib1NewTxPeriod = macCellCfg->sib1Cfg.sib1NewTxPeriod;
schCellCfg.sib1SchCfg.sib1RepetitionPeriod = macCellCfg->sib1Cfg.sib1RepetitionPeriod;
schCellCfg.sib1SchCfg.coresetZeroIndex = macCellCfg->sib1Cfg.coresetZeroIndex;
schCellCfg.sib1SchCfg.searchSpaceZeroIndex = macCellCfg->sib1Cfg.searchSpaceZeroIndex;
schCellCfg.sib1SchCfg.sib1Mcs = macCellCfg->sib1Cfg.sib1Mcs;
+ schCellCfg.sib1SchCfg.pageCfg.numPO = macCellCfg->sib1Cfg.pagingCfg.numPO;
+ schCellCfg.sib1SchCfg.pageCfg.poPresent = macCellCfg->sib1Cfg.pagingCfg.poPresent;
+
+ if(schCellCfg.sib1SchCfg.pageCfg.poPresent)
+ {
+ memcpy(schCellCfg.sib1SchCfg.pageCfg.pagingOcc, macCellCfg->sib1Cfg.pagingCfg.pagingOcc, MAX_PO_PER_PF);
+ }
/* fill RACH config params */
schCellCfg.schRachCfg.prachCfgIdx = macCellCfg->prachCfg.prachCfgIdx;
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(rsrcListIdx = 0; rsrcListIdx<macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc; rsrcListIdx++)
+ {
+ schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0 =
+ macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0;
+ schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
+ macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
+ schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
+ macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
+ schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol =
+ macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].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(rsrcListIdx = 0; rsrcListIdx < macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc; rsrcListIdx++)
+ {
+ schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2 =
+ macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2;
+ schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
+ macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
+ schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
+ macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
+ schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength =
+ macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength;
+ }
+
+ if(macCellCfg->plmnInfoList.snssai)
+ {
+ schCellCfg.plmnInfoList.numSliceSupport = macCellCfg->plmnInfoList.numSupportedSlice;
+ MAC_ALLOC(schCellCfg.plmnInfoList.snssai, schCellCfg.plmnInfoList.numSliceSupport * sizeof(Snssai*));
+ if(!schCellCfg.plmnInfoList.snssai)
+ {
+ DU_LOG("\nERROR --> MAC: Memory allocation failed at MacSchCellCfgReq");
+ return RFAILED;
+ }
+ for(sliceIdx=0; sliceIdx<schCellCfg.plmnInfoList.numSliceSupport; sliceIdx++)
+ {
+ if(macCellCfg->plmnInfoList.snssai[sliceIdx])
+ {
+ MAC_ALLOC(schCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
+ if(!schCellCfg.plmnInfoList.snssai[sliceIdx])
+ {
+ DU_LOG("\nERROR --> MAC: Memory allocation failed at MacSchCellCfgReq");
+ return RFAILED;
+ }
+ memcpy(schCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
+ }
+ }
+ }
+
+#ifdef NR_TDD
+ memcpy(&schCellCfg.tddCfg, &macCellCfg->tddCfg, sizeof(TDDCfg));
+#endif
FILL_PST_MAC_TO_SCH(cfgPst, EVENT_SCH_CELL_CFG);
{
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;
MacSendCellCfgCfm(cellId, RSP_OK);
}
+/*******************************************************************
+ *
+ * @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 */
+
+ memset(deleteRsp, 0, sizeof(MacCellDeleteRsp));
+ 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 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, sliceIdx = 0;
+ 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)
+ {
+ 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)
+ {
+ status = SUCCESSFUL_RSP;
+ if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai)
+ {
+ for(sliceIdx = 0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++)
+ {
+ MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
+ }
+ MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.\
+ numSupportedSlice * sizeof(Snssai*));
+ }
+ MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \
+ macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
+ 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;
+}
+
+/**
+ * @brief free the temporary slice cfg stored in macCb.
+ *
+ * @details
+ *
+ * Function : freeMacSliceCfgReq
+ *
+ * free the temporary slice cfg stored in macCb
+ *
+ * @param[in]
+ * @return int
+ * -# ROK
+ **/
+void freeMacSliceCfgReq(MacSliceCfgReq *cfgReq,Pst *pst)
+{
+ uint8_t cfgIdx = 0;
+
+ if(cfgReq)
+ {
+ if(cfgReq->numOfConfiguredSlice)
+ {
+ for(cfgIdx = 0; cfgIdx<cfgReq->numOfConfiguredSlice; cfgIdx++)
+ {
+ if(cfgReq->listOfSliceCfg[cfgIdx])
+ {
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio, sizeof(RrmPolicyRatio));
+ }
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg[cfgIdx], sizeof(MacSliceRrmPolicy));
+ }
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg, cfgReq->numOfConfiguredSlice * sizeof(MacSliceRrmPolicy*));
+ }
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq, sizeof(MacSliceCfgReq));
+ }
+}
+/**
+ * @brief fill Mac Slice Config Rsp
+ *
+ * @details
+ *
+ * Function : fillMacSliceCfgRsp
+ *
+ * This function fill Mac Slice Config Rsp
+ *
+ * @param[in] SchSliceCfgRsp *sliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp,
+ * uint8_t *count
+ * @return int
+ * -# ROK
+ **/
+uint8_t fillMacSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp)
+{
+
+ bool sliceFound = false;
+ uint8_t cfgIdx = 0;
+
+ macSliceCfgRsp->numSliceCfgRsp = schSliceCfgRsp->numSliceCfgRsp;
+ MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp, macSliceCfgRsp->numSliceCfgRsp* sizeof(MacSliceRsp*));
+ if(macSliceCfgRsp->listOfSliceCfgRsp == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failedi in fillMacSliceCfgRsp");
+ return RFAILED;
+ }
+
+ for(cfgIdx = 0; cfgIdx<schSliceCfgRsp->numSliceCfgRsp; cfgIdx++)
+ {
+ sliceFound = false;
+ if(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
+ {
+ sliceFound = true;
+ }
+
+ MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
+ if(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failedi in fillMacSliceCfgRsp");
+ return RFAILED;
+ }
+
+ macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai = schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai;
+ if(sliceFound == true)
+ macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp = MAC_DU_APP_RSP_OK;
+ else
+ {
+ macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp = MAC_DU_APP_RSP_NOK;
+ macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->cause = SLICE_NOT_PRESENT;
+ }
+ }
+ return ROK;
+}
+
+/**
+ * @brief send slice cfg response to duapp.
+ *
+ * @details
+ *
+ * Function : MacSendSliceConfigRsp
+ *
+ * sends slice cfg response to duapp
+ *
+ * @param[in] MacSliceCfgRsp macSliceCfgRsp
+ * @return int
+ * -# ROK
+ **/
+uint8_t MacSendSliceConfigRsp(MacSliceCfgRsp *macSliceCfgRsp)
+{
+ Pst rspPst;
+
+ memset(&rspPst, 0, sizeof(Pst));
+ FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_CFG_RSP);
+ return (*macDuSliceCfgRspOpts[rspPst.selector])(&rspPst, macSliceCfgRsp);
+
+}
+/**
+ * @brief free the slice cfg rsp received from sch.
+ *
+ * @details
+ *
+ * Function : freeSchSliceCfgRsp
+ *
+ * This free the slice cfg rsp received from sch
+ *
+ * @param[in] SchSliceCfgRsp *sliceCfgrsp
+ * @return int
+ * -# ROK
+ **/
+void freeSchSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp)
+{
+ uint8_t cfgIdx = 0;
+
+ if(schSliceCfgRsp)
+ {
+ if(schSliceCfgRsp->numSliceCfgRsp)
+ {
+ for(cfgIdx = 0; cfgIdx< schSliceCfgRsp->numSliceCfgRsp; cfgIdx++)
+ {
+ MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
+ }
+ MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*));
+ }
+ }
+}
+
+/**
+ * @brief Mac process the slice cfg rsp received from sch.
+ *
+ * @details
+ *
+ * Function : MacProcSchSliceCfgRsp
+ *
+ * This function process the slice cfg rsp received from sch
+ *
+ * @param[in] Pst *pst
+ * @param[in] SchSliceCfgRsp *sliceCfgrsp
+ * @return int
+ * -# ROK
+ **/
+uint8_t MacProcSchSliceCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceCfgRsp)
+{
+ MacSliceCfgRsp *macSliceCfgRsp = NULLP;
+
+ if(schSliceCfgRsp)
+ {
+ MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp, sizeof(MacSliceCfgRsp));
+ if(macSliceCfgRsp == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceCfgRsp");
+ return RFAILED;
+ }
+ if(schSliceCfgRsp->listOfSliceCfgRsp)
+ {
+ if(fillMacSliceCfgRsp(schSliceCfgRsp, macSliceCfgRsp) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to fill the slice cfg response");
+ return RFAILED;
+ }
+ MacSendSliceConfigRsp(macSliceCfgRsp);
+ }
+ freeSchSliceCfgRsp(schSliceCfgRsp);
+ }
+ return ROK;
+}
+
+/**
+* @brief send slice cfg response to duapp.
+*
+* @details
+*
+* Function : MacSendSliceReconfigRsp
+*
+* sends slice cfg response to duapp
+*
+* @param[in] MacSliceCfgRsp macSliceRecfgRsp
+* @return int
+* -# ROK
+**/
+uint8_t MacSendSliceReconfigRsp(MacSliceCfgRsp *macSliceRecfgRsp)
+{
+ Pst rspPst;
+
+ memset(&rspPst, 0, sizeof(Pst));
+ FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_RECFG_RSP);
+ return (*macDuSliceReCfgRspOpts[rspPst.selector])(&rspPst, macSliceRecfgRsp);
+
+}
+
+/**
+ * @brief Mac process the slice cfg rsp received from sch.
+ *
+ * @details
+ *
+ * Function : MacProcSchSliceReCfgRsp
+ *
+ * This function process the slice cfg rsp received from sch
+ *
+ * @param[in] Pst *pst
+ * @param[in] SchSliceCfgRsp *schSliceRecfgRsp
+ * @return int
+ * -# ROK
+ **/
+uint8_t MacProcSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceRecfgRsp)
+{
+ MacSliceCfgRsp *macSliceReCfgRsp = NULLP;
+
+ if(schSliceRecfgRsp)
+ {
+ MAC_ALLOC_SHRABL_BUF(macSliceReCfgRsp, sizeof(MacSliceCfgRsp));
+ if(macSliceReCfgRsp == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceReCfgRsp");
+ return RFAILED;
+ }
+
+ if(schSliceRecfgRsp->listOfSliceCfgRsp)
+ {
+ if(fillMacSliceCfgRsp(schSliceRecfgRsp, macSliceReCfgRsp) != ROK)
+ {
+ DU_LOG("\nERROR --> MAC : Failed to fill the slice Recfg response");
+ return RFAILED;
+ }
+ MacSendSliceReconfigRsp(macSliceReCfgRsp);
+ }
+ freeSchSliceCfgRsp(schSliceRecfgRsp);
+ }
+ return ROK;
+}
/**********************************************************************
End of file
**********************************************************************/
Code Review / o-du / l2.git / blobdiff