X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Fsch.c;h=f0bf4e79d9ee31fa99589b8e660a2bbb282dfcd7;hb=e97e12fe1ca460ef5437675bb94ad61740cf29e2;hp=090d3896df6d055ceaa8ae5eed315231ebb08627;hpb=8e6123e23f6d831b1fe972f8229e9594a2e92237;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index 090d3896d..f0bf4e79d 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -58,7 +58,20 @@ SchCellCfgCfmFunc SchCellCfgCfmOpts[] = packSchCellCfgCfm /* LWLC */ }; +SchSliceCfgRspFunc SchSliceCfgRspOpts[] = +{ + packSchSliceCfgRsp, /* LC */ + MacProcSchSliceCfgRsp, /* TC */ + packSchSliceCfgRsp /* LWLC */ + +}; +SchSliceReCfgRspFunc SchSliceReCfgRspOpts[] = +{ + packSchSliceReCfgRsp, /* LC */ + MacProcSchSliceReCfgRsp, /* TC */ + packSchSliceReCfgRsp /* LWLC */ +}; /** * @brief Task Initiation function. * @@ -167,7 +180,7 @@ uint8_t SchInstCfg(RgCfg *cfg, Inst dInst) /* Set Config done in TskInit */ schCb[inst].schInit.cfgDone = TRUE; - DU_LOG("\nINFO --> SCH : Scheduler gen config done"); + DU_LOG("\nINFO --> SCH : Scheduler gen config done"); return ret; } @@ -208,7 +221,7 @@ uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg) "pst->dstInst=%d SCH_INST_START=%d", pst->dstInst,SCH_INST_START); return ROK; } - DU_LOG("\nINFO --> SCH : Received scheduler gen config"); + DU_LOG("\nINFO --> SCH : Received scheduler gen config"); /* Fill the post structure for sending the confirmation */ memset(&cfmPst, 0 , sizeof(Pst)); SchFillCfmPst(pst, &cfmPst, cfg); @@ -1025,22 +1038,42 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) Inst schInst = pst->dstInst-SCH_INST_START; SchCellCb *cellCb = NULLP; SchUeCb *ueCb = NULLP; - uint8_t lcgIdx; + uint8_t lcgIdx = 0; #ifdef CALL_FLOW_DEBUG_LOG DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SHORT_BSR\n"); #endif DU_LOG("\nDEBUG --> SCH : Received BSR"); + if(bsrInd == NULLP) + { + DU_LOG("\nERROR --> SCH : BSR Ind is empty"); + return RFAILED; + } cellCb = schCb[schInst].cells[schInst]; + if(cellCb == NULLP) + { + DU_LOG("\nERROR --> SCH : CellCb is empty"); + return RFAILED; + } ueCb = schGetUeCb(cellCb, bsrInd->crnti); + if(ueCb == NULLP) + { + DU_LOG("\nERROR --> SCH : UeCB is empty"); + return RFAILED; + } + + ueCb->bsrRcvd = true; /* store dataVolume per lcg in uecb */ for(lcgIdx = 0; lcgIdx < bsrInd->numLcg; lcgIdx++) { - ueCb->bsrInfo[lcgIdx].priority = 1; //TODO: determining LCG priority? - ueCb->bsrInfo[lcgIdx].dataVol = bsrInd->dataVolInfo[lcgIdx].dataVol; + ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].priority = 1; //TODO: determining LCG priority? + ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].dataVol = bsrInd->dataVolInfo[lcgIdx].dataVol; } + + /* Adding UE Id to list of pending UEs to be scheduled */ + addUeToBeScheduled(cellCb, ueCb->ueIdx); return ROK; } @@ -1075,10 +1108,19 @@ uint8_t MacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd) DU_LOG("\nDEBUG --> SCH : Received SR"); ueCb = schGetUeCb(cellCb, uciInd->crnti); + + if(ueCb->state == SCH_UE_STATE_INACTIVE) + { + DU_LOG("\nERROR --> SCH : Crnti %d is inactive", uciInd->crnti); + return ROK; + } if(uciInd->numSrBits) { ueCb->srRcvd = true; + + /* Adding UE Id to list of pending UEs to be scheduled */ + addUeToBeScheduled(cellCb, ueCb->ueIdx); } return ROK; } @@ -1252,8 +1294,15 @@ uint8_t allocatePrbUl(SchCellCb *cell, SlotTimingInfo slotTime, \ bool isPrachOccasion; FreePrbBlock *freePrbBlock = NULLP; CmLList *freePrbNode = NULLP; - SchPrbAlloc *prbAlloc = &cell->schUlSlotInfo[slotTime.slot]->prbAlloc; + SchPrbAlloc *prbAlloc = NULLP; + if(cell == NULLP) + { + DU_LOG("\nERROR --> SCH : allocatePrbUl(): Received cellCb is null"); + return RFAILED; + } + + prbAlloc = &cell->schUlSlotInfo[slotTime.slot]->prbAlloc; /* If startPrb is set to MAX_NUM_RB, it means startPrb is not known currently. * Search for an appropriate location in PRB grid and allocate requested resources */ if(*startPrb == MAX_NUM_RB) @@ -1406,7 +1455,7 @@ uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) * * @details * - * Function : searchLargestFreeBlockDL + * Function : searchLargestFreeBlock * * Functionality: * Finds the FreeBlock with MaxNum of FREE PRB considering SSB/SIB1 ocassions. @@ -1414,6 +1463,7 @@ uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) * @params[in] I/P > prbAlloc table (FreeBlock list) * I/P > Slot timing Info * O/P > Start PRB + * I/P > Direction (UL/DL) * * * @return Max Number of Free PRB @@ -1421,38 +1471,70 @@ uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) * * ********************************************************************************/ -uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb) +uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb, Direction dir) { - uint16_t broadcastPrbStart=0, broadcastPrbEnd=0, maxFreePRB = 0; - PduTxOccsaion ssbOccasion=0, sib1Occasion=0; + uint16_t reservedPrbStart=0, reservedPrbEnd=0, maxFreePRB = 0; FreePrbBlock *freePrbBlock = NULLP; CmLList *freePrbNode = NULLP; + SchPrbAlloc *prbAlloc = NULLP; + bool checkOccasion = FALSE; - SchDlSlotInfo *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot]; - SchPrbAlloc *prbAlloc = &schDlSlotInfo->prbAlloc; - - ssbOccasion = schCheckSsbOcc(cell, slotTime); - sib1Occasion = schCheckSib1Occ(cell, slotTime); + *startPrb = 0; /*Initialize the StartPRB to zero*/ - if(ssbOccasion && sib1Occasion) + /*Based on Direction, Reserved Messsages will differi.e. + * DL >> SSB and SIB1 ocassions wheres for UL, PRACH ocassions to be checked + * and reserved before allocation for dedicated DL/UL msg*/ + if(dir == DIR_DL) { - broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; - broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + SchDlSlotInfo *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot]; + PduTxOccsaion ssbOccasion=0, sib1Occasion=0; + + prbAlloc = &schDlSlotInfo->prbAlloc; + + ssbOccasion = schCheckSsbOcc(cell, slotTime); + sib1Occasion = schCheckSib1Occ(cell, slotTime); + + checkOccasion = TRUE; + if(ssbOccasion && sib1Occasion) + { + reservedPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; + reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB + \ + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + } + else if(ssbOccasion) + { + reservedPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; + reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB -1; + } + else if(sib1Occasion) + { + reservedPrbStart = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.startPrb; + reservedPrbEnd = reservedPrbStart + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + } + else + { + checkOccasion = FALSE; + } } - else if(ssbOccasion) + else if(dir == DIR_UL) { - broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; - broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB -1; + prbAlloc = &cell->schUlSlotInfo[slotTime.slot]->prbAlloc; + + /* Check if PRACH is also scheduled in this slot */ + checkOccasion = schCheckPrachOcc(cell, slotTime); + if(checkOccasion) + { + reservedPrbStart = cell->cellCfg.schRachCfg.msg1FreqStart; + reservedPrbEnd = reservedPrbStart + (schCalcPrachNumRb(cell)) -1; + } } - else if(sib1Occasion) + else { - broadcastPrbStart = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.startPrb; - broadcastPrbEnd = broadcastPrbStart + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + DU_LOG("\nERROR --> SCH: Invalid Direction!"); + return (maxFreePRB); } - freePrbNode = prbAlloc->freePrbBlockList.first; - *startPrb = 0; /*Initialize the StartPRB to zero*/ while(freePrbNode) { freePrbBlock = (FreePrbBlock *)freePrbNode->node; @@ -1466,27 +1548,27 @@ uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint1 continue; } - /* If broadcast message is scheduled in this slot, then check if its PRBs belong to the current free block. + /* If Broadcast/Prach message is scheduled in this slot, then check if its PRBs belong to the current free block. * Since SSB/SIB1 PRB location is fixed, these PRBs cannot be allocated to other message in same slot */ - if((ssbOccasion || sib1Occasion) && - ((broadcastPrbStart >= freePrbBlock->startPrb) && (broadcastPrbStart <= freePrbBlock->endPrb)) && \ - ((broadcastPrbEnd >= freePrbBlock->startPrb) && (broadcastPrbEnd <= freePrbBlock->endPrb))) + if(checkOccasion && + ((reservedPrbStart >= freePrbBlock->startPrb) && (reservedPrbStart <= freePrbBlock->endPrb)) && \ + ((reservedPrbEnd >= freePrbBlock->startPrb) && (reservedPrbEnd <= freePrbBlock->endPrb))) { /* Implmentation is done such that highest-numbered free-RB is Checked first and freePRB in this block is greater than Max till now */ - if((freePrbBlock->endPrb > broadcastPrbEnd) && ((freePrbBlock->endPrb - broadcastPrbEnd) > maxFreePRB)) + if((freePrbBlock->endPrb > reservedPrbEnd) && ((freePrbBlock->endPrb - reservedPrbEnd) > maxFreePRB)) { - /* If sufficient free PRBs are available above broadcast message*/ - *startPrb = broadcastPrbEnd + 1; - maxFreePRB = (freePrbBlock->endPrb - broadcastPrbEnd); + /* If sufficient free PRBs are available above reserved message*/ + *startPrb = reservedPrbEnd + 1; + maxFreePRB = (freePrbBlock->endPrb - reservedPrbEnd); } - /*Also check the other freeBlock (i.e. Above the broadcast message) for MAX FREE PRB*/ - if((broadcastPrbStart > freePrbBlock->startPrb) && ((broadcastPrbStart - freePrbBlock->startPrb) > maxFreePRB)) + /*Also check the other freeBlock (i.e. Above the reserved message) for MAX FREE PRB*/ + if((reservedPrbStart > freePrbBlock->startPrb) && ((reservedPrbStart - freePrbBlock->startPrb) > maxFreePRB)) { - /* If free PRBs are available below broadcast message*/ + /* If free PRBs are available below reserved message*/ *startPrb = freePrbBlock->startPrb; - maxFreePRB = (broadcastPrbStart - freePrbBlock->startPrb); + maxFreePRB = (reservedPrbStart - freePrbBlock->startPrb); } } else //Best Block @@ -1503,6 +1585,393 @@ uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint1 return(maxFreePRB); } +/******************************************************************************* + * + * @brief This function is used to send Slice Cfg rsp to MAC + * + * @details + * + * Function : SchSendSliceCfgRspToMac + * + * Functionality: + * function is used to send Slice Cfg rsp to MAC + * + * @params[in] Pst *pst, SchSliceCfgRsp sliceCfgRsp + * + * @return- void + * + * ********************************************************************************/ +void SchSendSliceCfgRspToMac(Inst inst, SchSliceCfgRsp sliceCfgRsp) +{ + Pst rspPst; + + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(rspPst, inst); + rspPst.event = EVENT_SLICE_CFG_RSP_TO_MAC; + + SchSliceCfgRspOpts[rspPst.selector](&rspPst, &sliceCfgRsp); + +} +/******************************************************************************* + * + * @brief fill slice configuration response + * + * @details + * + * Function : fillSliceCfgRsp + * + * Functionality: + * fill slice configuration response + * + * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t count + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t fillSliceCfgRsp(bool sliceReCfg, SchSliceCfg *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq, SchSliceCfgRsp *schSliceCfgRsp, uint8_t *count) +{ + bool sliceFound = false; + uint8_t cfgIdx = 0, sliceIdx = 0; + + schSliceCfgRsp->numSliceCfgRsp = schSliceCfgReq->numOfConfiguredSlice; + SCH_ALLOC(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*)); + if(schSliceCfgRsp->listOfSliceCfgRsp == NULLP) + { + DU_LOG("\nERROR --> SCH : Memory allocation failed at fillSliceCfgRsp"); + return RFAILED; + } + + for(cfgIdx = 0; cfgIdxnumSliceCfgRsp ; cfgIdx++) + { + sliceFound = false; + /* Here comparing the slice cfg request with the slice stored in cellCfg */ + if(sliceReCfg != true) + { + for(sliceIdx = 0; sliceIdxcellCfg.plmnInfoList.numSliceSupport; sliceIdx++) + { + if(!memcmp(&schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai, cellCb->cellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai))) + { + (*count)++; + sliceFound = true; + break; + } + } + } + else + { + /* Here comparing the slice cfg request with the slice stored in SchDb */ + if(storedSliceCfg->listOfConfirguration) + { + for(sliceIdx = 0; sliceIdxnumOfSliceConfigured; sliceIdx++) + { + if(!memcmp(&schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai, &storedSliceCfg->listOfConfirguration[sliceIdx]->snssai,\ + sizeof(Snssai))) + { + (*count)++; + sliceFound = true; + break; + } + } + } + } + + SCH_ALLOC(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp)); + if(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx] == NULLP) + { + DU_LOG("\nERROR --> SCH : Failed to allocate memory in fillSliceCfgRsp"); + return RFAILED; + } + + + schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai = schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai; + if(sliceFound == true) + schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp = RSP_OK; + else + { + schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp = RSP_NOK; + schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->cause = SLICE_NOT_FOUND; + } + } + return ROK; +} + +/******************************************************************************* + * + * @brief This function is used to store the slice configuration Sch DB + * + * @details + * + * Function : addSliceCfgInSchDb + * + * Functionality: + * function is used to store the slice configuration Sch DB + * + * @params[in] SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, + * SchSliceCfgRsp cfgRsp, uint8_t count + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t addSliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, SchSliceCfgRsp cfgRsp, uint8_t count) +{ + uint8_t cfgIdx = 0, sliceIdx = 0; + + if(count) + { + storeSliceCfg->numOfSliceConfigured = count; + SCH_ALLOC(storeSliceCfg->listOfConfirguration, storeSliceCfg->numOfSliceConfigured * sizeof(SchRrmPolicyOfSlice*)); + if(storeSliceCfg->listOfConfirguration == NULLP) + { + DU_LOG("\nERROR --> SCH : Failed to allocate memory in addSliceCfgInSchDb"); + return RFAILED; + } + + for(cfgIdx = 0; cfgIdxnumOfSliceConfigured; cfgIdx++) + { + if(cfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK) + { + SCH_ALLOC(storeSliceCfg->listOfConfirguration[sliceIdx], sizeof(SchRrmPolicyOfSlice)); + if(storeSliceCfg->listOfConfirguration[sliceIdx] == NULLP) + { + DU_LOG("\nERROR --> SCH : Failed to allocate memory in addSliceCfgInSchDb"); + return RFAILED; + } + + SCH_ALLOC(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); + if(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo == NULLP) + { + DU_LOG("\nERROR --> SCH : Failed to allocate memory in addSliceCfgInSchDb"); + return RFAILED; + } + + memcpy(storeSliceCfg->listOfConfirguration[sliceIdx], cfgReq->listOfConfirguration[sliceIdx], sizeof(SchRrmPolicyOfSlice)); + sliceIdx++; + } + } + } + return ROK; +} + +/******************************************************************************* + * + * @brief This function is used to free the slice cfg and re cfg request pointer + * + * @details + * + * Function : freeSchSliceCfgReq + * + * Functionality: + * function is used to free the slice cfg and re cfg request pointer + * + * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq + * + * @return + * ROK - Success + * RFAILED - Failure + * ********************************************************************************/ +void freeSchSliceCfgReq(SchSliceCfgReq *cfgReq) +{ + uint8_t cfgIdx = 0; + + if(cfgReq) + { + if(cfgReq->numOfConfiguredSlice) + { + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + { + if(cfgReq->listOfConfirguration[cfgIdx]) + { + SCH_FREE(cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); + SCH_FREE(cfgReq->listOfConfirguration[cfgIdx], sizeof(SchRrmPolicyOfSlice)); + } + } + SCH_FREE(cfgReq->listOfConfirguration, cfgReq->numOfConfiguredSlice * sizeof(SchRrmPolicyOfSlice*)); + } + SCH_FREE(cfgReq, sizeof(SchSliceCfgReq)); + } +} +/******************************************************************************* + * + * @brief This function is used to store the slice configuration Sch DB + * + * @details + * + * Function : MacSchSliceCfgReq + * + * Functionality: + * function is used to store the slice configuration Sch DB + * + * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t MacSchSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq) +{ + uint8_t count = 0; + Inst inst = pst->dstInst - 1; + SchSliceCfgRsp sliceCfgRsp; + + DU_LOG("\nINFO --> SCH : Received Slice Cfg request from MAC"); + if(schSliceCfgReq) + { + if(schSliceCfgReq->listOfConfirguration) + { + /* filling the slice configuration response of each slice */ + if(fillSliceCfgRsp(false, NULLP, schCb[inst].cells[0], schSliceCfgReq, &sliceCfgRsp, &count) != ROK) + { + DU_LOG("\nERROR --> SCH : Failed to fill the slice cfg rsp"); + return RFAILED; + } + + if(addSliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceCfgReq, sliceCfgRsp, count) != ROK) + { + DU_LOG("\nERROR --> SCH : Failed to add slice cfg in sch database"); + return RFAILED; + } + freeSchSliceCfgReq(schSliceCfgReq); + SchSendSliceCfgRspToMac(inst, sliceCfgRsp); + } + } + else + { + DU_LOG("\nERROR --> SCH : Received SchSliceCfgReq is NULL"); + } + return ROK; +} + +/******************************************************************************* + * + * @brief This function is used to store the slice reconfiguration Sch DB + * + * @details + * + * Function : modifySliceCfgInSchDb + * + * Functionality: + * function is used to store the slice re configuration Sch DB + * + * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, SchSliceCfgRsp cfgRsp, uint8_t count) +{ + uint8_t cfgIdx = 0, sliceIdx = 0; + + if(count) + { + if(storeSliceCfg->listOfConfirguration == NULLP) + { + DU_LOG("\nINFO --> SCH : Memory allocation failed in modifySliceCfgInSchDb"); + return RFAILED; + } + + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + { + if(cfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK) + { + for(sliceIdx = 0; sliceIdxnumOfSliceConfigured; sliceIdx++) + { + if(!memcmp(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &cfgReq->listOfConfirguration[cfgIdx]->snssai, sizeof(Snssai))) + { + storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo = cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo; + break; + } + } + } + } + } + freeSchSliceCfgReq(cfgReq); + return ROK; +} +/******************************************************************************* + * + * @brief This function is used to send Slice re Cfg rsp to MAC + * + * @details + * + * Function : SchSendSliceCfgRspToMac + * + * Functionality: + * function is used to send Slice re Cfg rsp to MAC + * + * @params[in] Pst *pst, SchSliceCfgRsp schSliceReCfgRsp + * + * @return- void + * + * ********************************************************************************/ +void SchSendSliceReCfgRspToMac(Inst inst, SchSliceCfgRsp schSliceReCfgRsp) +{ + Pst rspPst; + + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(rspPst, inst); + rspPst.event = EVENT_SLICE_RECFG_RSP_TO_MAC; + + SchSliceReCfgRspOpts[rspPst.selector](&rspPst, &schSliceReCfgRsp); +} +/******************************************************************************* + * + * @brief This function is used to store the slice reconfiguration Sch DB + * + * @details + * + * Function : MacSchSliceReCfgReq + * + * Functionality: + * function is used to store the slice re configuration Sch DB + * + * @params[in] Pst *pst, SchSliceCfgReq *schSliceReCfgReq + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t MacSchSliceReCfgReq(Pst *pst, SchSliceCfgReq *schSliceReCfgReq) +{ + uint8_t count = 0; + Inst inst = pst->dstInst - 1; + SchSliceCfgRsp schSliceReCfgRsp; + + DU_LOG("\nINFO --> SCH : Received Slice ReCfg request from MAC"); + if(schSliceReCfgReq) + { + if(schSliceReCfgReq->listOfConfirguration) + { + /* filling the slice configuration response of each slice */ + if(fillSliceCfgRsp(true, &schCb[inst].sliceCfg, NULLP, schSliceReCfgReq, &schSliceReCfgRsp, &count) != ROK) + { + DU_LOG("\nERROR --> SCH : Failed to fill sch slice cfg response"); + return RFAILED; + } + + /* Modify the slice configuration stored in schCb */ + if(modifySliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceReCfgReq, schSliceReCfgRsp, count) != ROK) + { + DU_LOG("\nERROR --> SCH : Failed to modify slice cfg of SchDb"); + return RFAILED; + } + SchSendSliceReCfgRspToMac(inst, schSliceReCfgRsp); + } + } + else + { + DU_LOG("\nERROR --> SCH : Received SchSliceCfgReq is NULL"); + } + return ROK; +} + /********************************************************************** End of file **********************************************************************/