X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Fsch.c;h=d05029ddf34306b973ed572d4f0fceb9478b4187;hb=aae1fb8fd1e149a7b3a6a6ca799c56aceadc6184;hp=2cb4c544ac1c1be5744d21ff0cc4633e9666df30;hpb=154ac5a3676b120c741184f7e58627df8003b5c0;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index 2cb4c544a..d05029ddf 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -58,6 +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. @@ -129,9 +143,7 @@ uint8_t SchInstCfg(RgCfg *cfg, Inst dInst) return LCM_REASON_INVALID_MSGTYPE; } /* Update the Pst structure for LM interface */ - memcpy(&schCb[inst].schInit.lmPst, - &cfg->s.schInstCfg.genCfg.lmPst, - sizeof(Pst)); + memcpy(&schCb[inst].schInit.lmPst, &cfg->s.schInstCfg.genCfg.lmPst, sizeof(Pst)); schCb[inst].schInit.inst = inst; schCb[inst].schInit.lmPst.srcProcId = schCb[inst].schInit.procId; @@ -157,8 +169,7 @@ uint8_t SchInstCfg(RgCfg *cfg, Inst dInst) /* SS_MT_TMR needs to be enabled as schActvTmr needs instance information */ /* Timer Registration request to system services */ - if (ODU_REG_TMR_MT(schCb[inst].schInit.ent, dInst, - (int)schCb[inst].genCfg.tmrRes, schActvTmr) != ROK) + if (ODU_REG_TMR_MT(schCb[inst].schInit.ent, dInst, (int)schCb[inst].genCfg.tmrRes, schActvTmr) != ROK) { DU_LOG("\nERROR --> SCH : SchInstCfg(): Failed to " "register timer."); @@ -324,22 +335,12 @@ uint8_t MacSchRachInd(Pst *pst, RachIndInfo *rachInd) * ****************************************************************/ uint8_t MacSchCrcInd(Pst *pst, CrcIndInfo *crcInd) { + Inst inst = pst->dstInst-SCH_INST_START; #ifdef CALL_FLOW_DEBUG_LOG DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_CRC_IND_TO_SCH\n"); #endif - switch(crcInd->crcInd[0]) - { - case CRC_FAILED: - DU_LOG("\nDEBUG --> SCH : Received CRC indication. CRC Status [FAILURE]"); - break; - case CRC_PASSED: - DU_LOG("\nDEBUG --> SCH : Received CRC indication. CRC Status [PASS]"); - break; - default: - DU_LOG("\nDEBUG --> SCH : Invalid CRC state %d", crcInd->crcInd[0]); - return RFAILED; - } + schProcessCrcInd(crcInd, inst); return ROK; } @@ -665,6 +666,10 @@ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) cell->firstSib1Transmitted = false; fillSsbStartSymb(cell); cmLListInit(&cell->ueToBeScheduled); + +#ifdef NR_DRX + memset(cell->drxCb, 0, MAX_DRX_SIZE*sizeof(SchDrxCb)); +#endif schCb[inst].cells[inst] = cell; DU_LOG("\nINFO --> SCH : Cell init completed for cellId:%d", cell->cellId); @@ -855,7 +860,7 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) SchCellCb *cellCb; SchCellCfgCfm schCellCfgCfm; Pst rspPst; - Inst inst = pst->dstInst-1; + Inst inst = pst->dstInst - SCH_INST_START; uint8_t coreset0Idx = 0; uint8_t numRbs = 0; uint8_t offset = 0; @@ -874,7 +879,10 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) fillSchSib1Cfg(schCellCfg->numerology, schCellCfg->bandwidth, cellCb->numSlots, &(schCellCfg->sib1SchCfg), schCellCfg->phyCellId, schCellCfg->ssbSchCfg.ssbOffsetPointA); + + memcpy(&cellCb->cellCfg, schCellCfg, sizeof(SchCellCfg)); + schProcPagingCfg(cellCb); /* Fill coreset frequencyDomainResource bitmap */ coreset0Idx = cellCb->cellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId; @@ -895,6 +903,11 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) cellCb->actvUeBitMap = 0; cellCb->boIndBitMap = 0; + cellCb->cellCfg.schHqCfg.maxDlDataHqTx = SCH_MAX_NUM_DL_HQ_TX; + cellCb->cellCfg.schHqCfg.maxMsg4HqTx = SCH_MAX_NUM_MSG4_TX; + cellCb->cellCfg.schHqCfg.maxUlDataHqTx = SCH_MAX_NUM_UL_HQ_TX; + cellCb->cellCfg.schRachCfg.maxMsg3Tx = SCH_MAX_NUM_MSG3_TX; + /* Fill and send Cell config confirm */ memset(&rspPst, 0, sizeof(Pst)); FILL_PST_SCH_TO_MAC(rspPst, pst->dstInst); @@ -931,13 +944,11 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) bool isLcIdValid = false; SchUeCb *ueCb = NULLP; SchCellCb *cell = NULLP; - Inst inst = pst->dstInst-SCH_INST_START; - CmLListCp *lcLL = NULLP; + Inst inst = pst->dstInst-SCH_INST_START; #ifdef CALL_FLOW_DEBUG_LOG DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_DL_RLC_BO_INFO_TO_SCH\n"); -#endif - +#endif DU_LOG("\nDEBUG --> SCH : Received RLC BO Status indication LCId [%d] BO [%d]", dlBoInfo->lcId, dlBoInfo->dataVolume); cell = schCb[inst].cells[inst]; @@ -947,8 +958,14 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) return RFAILED; } - GET_UE_IDX(dlBoInfo->crnti, ueId); + GET_UE_ID(dlBoInfo->crnti, ueId); ueCb = &cell->ueCb[ueId-1]; + if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION) + { + DU_LOG("INFO --> SCH : DL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId); + return ROK; + } + lcId = dlBoInfo->lcId; CHECK_LCID(lcId, isLcIdValid); if(isLcIdValid == FALSE) @@ -962,25 +979,15 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) *Thus clearing out the LC from the Lc priority list*/ if(dlBoInfo->dataVolume == 0) { - /*Check the LC is Dedicated or default and accordingly LCList will - * be used*/ - if(ueCb->dlInfo.dlLcCtxt[lcId].isDedicated) - { - lcLL = &(ueCb->dlLcPrbEst.dedLcInfo->dedLcList); - } - else - { - lcLL = &(ueCb->dlLcPrbEst.defLcList); - } - handleLcLList(lcLL, lcId, DELETE); + /* TODO : Check the LC is Dedicated or default and accordingly LCList + * will be used*/ return ROK; } if(lcId == SRB0_LCID) { cell->raCb[ueId -1].msg4recvd = true; - cell->raCb[ueId -1].dlMsgPduLen = dlBoInfo->dataVolume; - + cell->raCb[ueId -1].dlMsgPduLen = dlBoInfo->dataVolume; } else { @@ -997,7 +1004,6 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) return RFAILED; } } - /* Adding UE Id to list of pending UEs to be scheduled */ addUeToBeScheduled(cell, ueId); return ROK; @@ -1051,6 +1057,12 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) return RFAILED; } + if(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION) + { + DU_LOG("\nINFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId); + return ROK; + } + ueCb->bsrRcvd = true; /* store dataVolume per lcg in uecb */ for(lcgIdx = 0; lcgIdx < bsrInd->numLcg; lcgIdx++) @@ -1060,7 +1072,7 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) } /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cellCb, ueCb->ueIdx); + addUeToBeScheduled(cellCb, ueCb->ueId); return ROK; } @@ -1095,17 +1107,68 @@ 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(ueCb->ueCfg.dataTransmissionAction == STOP_DATA_TRANSMISSION) + { + DU_LOG("\nINFO --> SCH: UL Data transmission not allowed for UE %d", ueCb->ueCfg.ueId); + return ROK; + } if(uciInd->numSrBits) { - ueCb->srRcvd = true; - + ueCb->srRcvd = true; /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cellCb, ueCb->ueIdx); + addUeToBeScheduled(cellCb, ueCb->ueId); } return ROK; } +/******************************************************************* + * + * @brief Processes DL HARQ indication from MAC + * + * @details + * + * Function : MacSchDlHarqInd + * + * Functionality: + * Processes DL HARQ indication from MAC + * + * @params[in] Post structure + * DL HARQ Indication + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t MacSchDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd) +{ + Inst inst = pst->dstInst-SCH_INST_START; + SchUeCb *ueCb; + SchCellCb *cellCb = schCb[inst].cells[inst]; + +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_DL_HARQ_IND_TO_SCH\n"); +#endif + + DU_LOG("\nDEBUG --> SCH : Received HARQ"); + + ueCb = schGetUeCb(cellCb, dlHarqInd->crnti); + + if(ueCb->state == SCH_UE_STATE_INACTIVE) + { + DU_LOG("\nERROR --> SCH : Crnti %d is inactive", dlHarqInd->crnti); + return ROK; + } + + schUpdateHarqFdbk(ueCb, dlHarqInd->numHarq, dlHarqInd->harqPayload, &dlHarqInd->slotInd); + + return ROK; +} + /******************************************************************* * * @brief Allocates requested PRBs for DL @@ -1275,8 +1338,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) @@ -1417,7 +1487,7 @@ uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) *ueId = ueIdToAdd; if(addNodeToLList(&cell->ueToBeScheduled, ueId, NULLP) != ROK) { - DU_LOG("\nERROR --> SCH : Failed to add UeIdx to cell->ueToBeScheduled list"); + DU_LOG("\nERROR --> SCH : Failed to add ueId [%d] to cell->ueToBeScheduled list", *ueId); return RFAILED; } return ROK; @@ -1558,6 +1628,659 @@ uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_ } 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]->snssai, &cfgReq->listOfConfirguration[sliceIdx]->snssai, sizeof(Snssai)); + memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, cfgReq->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, + sizeof(SchRrmPolicyRatio)); + 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 *sliceCfgReq) +{ + uint8_t cfgIdx = 0; + + if(sliceCfgReq) + { + if(sliceCfgReq->numOfConfiguredSlice) + { + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + { + if(sliceCfgReq->listOfConfirguration[cfgIdx]) + { + SCH_FREE(sliceCfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); + SCH_FREE(sliceCfgReq->listOfConfirguration[cfgIdx], sizeof(SchRrmPolicyOfSlice)); + } + } + SCH_FREE(sliceCfgReq->listOfConfirguration, sliceCfgReq->numOfConfiguredSlice * sizeof(SchRrmPolicyOfSlice*)); + } + SCH_FREE(sliceCfgReq, 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 - SCH_INST_START; + 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, SchSliceRecfgReq *recfgReq, SchSliceRecfgRsp recfgRsp, 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(recfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK) + { + for(sliceIdx = 0; sliceIdxnumOfSliceConfigured; sliceIdx++) + { + if(!memcmp(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &recfgReq->listOfConfirguration[cfgIdx]->snssai, sizeof(Snssai))) + { + memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, recfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, + sizeof(SchRrmPolicyRatio)); + break; + } + } + } + } + } + freeSchSliceCfgReq(recfgReq); + return ROK; +} +/******************************************************************************* + * + * @brief This function is used to send Slice re Cfg rsp to MAC + * + * @details + * + * Function : SchSendSliceRecfgRspToMac + * + * Functionality: + * function is used to send Slice re Cfg rsp to MAC + * + * @params[in] Pst *pst, SchSliceRecfgRsp schSliceRecfgRsp + * + * @return- void + * + * ********************************************************************************/ +void SchSendSliceRecfgRspToMac(Inst inst, SchSliceRecfgRsp 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, SchSliceRecfgReq *schSliceRecfgReq + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ +uint8_t MacSchSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq) +{ + uint8_t count = 0; + Inst inst = pst->dstInst - SCH_INST_START; + SchSliceRecfgRsp 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 SchSliceRecfgReq is NULL"); + } + return ROK; +} + +/**************************************************************************** + * + * @brief Stores the Paging Configuration from DU APP in CellCb + * + * @details + * + * Function : schProcPagingParam + * + * Functionality: + * Process the Paging Configuration when FirstPDCCHMonitoring for + * Paging Ocassion is not present. + * + * As per 38.304 Sec 7.1, + * "When firstPDCCH-MonitoringOccasionOfPO is present, the + * starting PDCCH monitoring occasion number of (i_s + 1)th PO is the + * (i_s + 1)th value of the firstPDCCHMonitoringOccasionOfPO + * parameter; otherwise, it is equal to i_s * S." + * "S = number of actual transmitted SSBs determined according + * to ssb-PositionsInBurst in SIB1" + * + * @params[in] SchCellCb *cell + * + * @return void + * + *************************************************************************/ +void schProcPagingCfg(SchCellCb *cell) +{ + PageCfg *pageCfgRcvd = NULL; + uint8_t i_sIdx = 0; + + pageCfgRcvd = &(cell->cellCfg.sib1SchCfg.pageCfg); + + if(pageCfgRcvd->poPresent == TRUE) + { + /*Fetching first Pdcch Monitoring Occasion for SFN (i_s + 1)th*/ + for(i_sIdx = 0; i_sIdx < pageCfgRcvd->numPO; i_sIdx++) + { + cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot = pageCfgRcvd->pagingOcc[i_sIdx] / MAX_SYMB_PER_SLOT ; + if ((pageCfgRcvd->pagingOcc[i_sIdx] % MAX_SYMB_PER_SLOT) != 0 ) + { + cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot++; + } + + cell->pageCb.pagMonOcc[i_sIdx].frameOffset = 0; + + } + } + else + { + schCfgPdcchMonOccOfPO(cell); + } +} + +/**************************************************************************** + * + * @brief Calculate PO if not present in Configuration + * + * @details + * + * Function : schCfgPdcchMonOccOfPO + * + * Functionality: In this function, PO are calculated i_s * S because + * FirstPDCCHMonitoring_ForPO is not present. + * + * @params[in] SchCellCb *cellCb + * + * @return void + * + *************************************************************************/ +void schCfgPdcchMonOccOfPO(SchCellCb *cell) +{ + uint8_t cnt = 0, incr = 1, i_sIdx = 0, frameOffSet = 0; + uint8_t nsValue = cell->cellCfg.sib1SchCfg.pageCfg.numPO; + uint8_t totalNumSsb = cell->cellCfg.ssbSchCfg.totNumSsb; + SlotTimingInfo tmpTimingInfo, pdcchTime; + + /*Starting with First Sfn and slot*/ + tmpTimingInfo.sfn = 0; + tmpTimingInfo.slot = 0; + + pdcchTime = tmpTimingInfo; + + while(i_sIdx < nsValue) + { + /*Increment frame Offset if PO falls on next SFN*/ + if(pdcchTime.sfn != tmpTimingInfo.sfn) + { + frameOffSet++; + } + pdcchTime = tmpTimingInfo; + schIncrSlot(&(tmpTimingInfo), incr, cell->numSlots); + + if (i_sIdx == 0) + { + cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot = pdcchTime.slot; + cell->pageCb.pagMonOcc[i_sIdx].frameOffset = frameOffSet; + i_sIdx++; + } + else + { + cnt++; + if((cnt == totalNumSsb) && (i_sIdx < MAX_PO_PER_PF)) + { + cell->pageCb.pagMonOcc[i_sIdx].pagingOccSlot = pdcchTime.slot; + cell->pageCb.pagMonOcc[i_sIdx].frameOffset = frameOffSet; + cnt = 0; + i_sIdx++; + } + } + } +} + +/**************************************************************************** + * + * @brief Storing the paging information in SCH database + * + * @details + * + * Function : schAddPagingIndtoList + * + * Functionality: Storing the paging information in SCH database + * + * @params[in] CmLListCp *storedPageList, CmLList *pageIndInfo + * + * @return ROK - sucess + * RFAILED - failure + * + *************************************************************************/ +uint8_t schAddPagingIndtoList(CmLListCp *storedPageList,void * pageIndInfo) +{ + CmLList *firstNodeOfList = NULLP; + CmLList *currentNodeInfo = NULLP; + SchPageInfo *tempNode = NULLP, *recvdNode = NULLP; + + recvdNode = (SchPageInfo*) pageIndInfo; + CM_LLIST_FIRST_NODE(storedPageList,firstNodeOfList); + + SCH_ALLOC(currentNodeInfo, sizeof(CmLList)); + if(!currentNodeInfo) + { + DU_LOG("\nERROR --> SCH : schAddPagingIndtoList() : Memory allocation failed"); + return RFAILED; + } + + currentNodeInfo->node = (PTR)pageIndInfo; + while(firstNodeOfList) + { + tempNode = (SchPageInfo*)(firstNodeOfList->node); + if ((recvdNode->pageTxTime.slot < tempNode->pageTxTime.slot)) + { + cmLListInsCrnt(storedPageList, currentNodeInfo); + break; + } + else if ((recvdNode->pageTxTime.slot == tempNode->pageTxTime.slot)) + { + DU_LOG("\nERROR --> SCH : schAddPagingIndtoList() : Slot[%d] is already present in the list", recvdNode->pageTxTime.slot); + return RFAILED; + } + else + { + CM_LLIST_NEXT_NODE(storedPageList, firstNodeOfList); + } + } + + if(!firstNodeOfList) + { + cmLListAdd2Tail(storedPageList, currentNodeInfo); + } + DU_LOG("\nDEBUG --> SCH : Paging information is stored successfully for PF:%d, Slot:%d",\ + recvdNode->pageTxTime.sfn, recvdNode->pageTxTime.slot); + return ROK; +} + +/**************************************************************************** + * + * @brief Process paging indication at SCH recevied form MAC + * + * @details + * + * Function : MacSchPagingInd + * + * Functionality: Process paging indication at SCH recevied form MAC + * + * @params[in] Pst *pst, SchPageInd *pageInd + * + * @return void + * + *************************************************************************/ +uint8_t MacSchPagingInd(Pst *pst, SchPageInd *pageInd) +{ + uint8_t ret = RFAILED; + uint16_t cellIdx = 0; + Inst inst = pst->dstInst - SCH_INST_START; + SchCellCb *cellCb = NULLP; + SchPageInfo *pageInfo = NULLP; + + if(pageInd) + { + DU_LOG("\nDEBUG --> SCH : Received paging indication from MAC for cellId[%d]",\ + pageInd->cellId); + + /* Fetch Cell CB */ + for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++) + { + if((schCb[inst].cells[cellIdx]) && (schCb[inst].cells[cellIdx]->cellId == pageInd->cellId)) + { + cellCb = schCb[inst].cells[cellIdx]; + break; + } + } + if(cellCb) + { + if(pageInd->i_s > cellCb->cellCfg.sib1SchCfg.pageCfg.numPO) + { + DU_LOG("\nERROR --> SCH : MacSchPagingInd(): i_s should not be greater than number of paging occasion"); + } + else + { + SCH_ALLOC(pageInfo, sizeof(SchPageInfo)); + if(pageInfo) + { + pageInfo->pf = pageInd->pf; + pageInfo->i_s = pageInd->i_s; + pageInfo->pageTxTime.cellId = pageInd->cellId; + pageInfo->pageTxTime.sfn = (pageInd->pf + cellCb->pageCb.pagMonOcc[pageInd->i_s].frameOffset) % MAX_SFN; + pageInfo->pageTxTime.slot = cellCb->pageCb.pagMonOcc[pageInd->i_s].pagingOccSlot; + pageInfo->mcs = DEFAULT_MCS; + pageInfo->msgLen = pageInd->pduLen; + SCH_ALLOC(pageInfo->pagePdu, pageInfo->msgLen); + if(!pageInfo->pagePdu) + { + DU_LOG("\nERROR --> SCH : MacSchPagingInd(): Failed to allocate memory"); + } + else + { + memcpy(pageInfo->pagePdu, pageInd->pagePdu, pageInfo->msgLen); + ret = schAddPagingIndtoList(&cellCb->pageCb.pageIndInfoRecord[pageInfo->pageTxTime.sfn], pageInfo); + if(ret != ROK) + { + DU_LOG("\nERROR --> SCH : MacSchPagingInd(): Failed to store paging record"); + } + } + } + else + { + DU_LOG("\nERROR --> SCH : MacSchPagingInd(): Failed to allocate memory"); + } + } + } + else + { + DU_LOG("\nERROR --> SCH : Cell ID [%d] not found", pageInd->cellId); + } + SCH_FREE(pageInd->pagePdu, pageInd->pduLen); + SCH_FREE(pageInd, sizeof(SchPageInd)); + } + else + { + DU_LOG("\nERROR --> SCH : MacSchPagingInd(): Received null pointer"); + } + return ret; +} /********************************************************************** End of file **********************************************************************/