X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Fsch.c;h=293add2bbd08d2165858d9bbf6969e3dd82fcc5c;hb=refs%2Fchanges%2F39%2F11539%2F5;hp=8aa6d0aef23a67c9b4a83e5073d4a1927a7a4a01;hpb=ad03183bb3801c735151b22dae88c9d28a962838;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index 8aa6d0aef..293add2bb 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -319,6 +319,48 @@ uint16_t schGetPeriodicityInMsec(DlUlTxPeriodicity tddPeriod) return periodicityInMsec; } +/** + *@brief Fills the slotCfg from CellCfg + * + * @details + * + * Function : schFillSlotConfig + * + * This API Fills the slotCfg from CellCfg + * + * @param[in] SchCellCb *cell, TDDCfg tddCfg + * @return void + * **/ +void schFillSlotConfig(SchCellCb *cell, TDDCfg tddCfg) +{ + uint8_t slotIdx = 0, symbolIdx = 0; + + for(slotIdx =0 ;slotIdx < MAX_TDD_PERIODICITY_SLOTS; slotIdx++) + { + for(symbolIdx = 0; symbolIdx < MAX_SYMB_PER_SLOT; symbolIdx++) + { + /*Fill Full-DL Slots as well as DL symbols ini 1st Flexi Slo*/ + if(slotIdx < tddCfg.nrOfDlSlots || \ + (slotIdx == tddCfg.nrOfDlSlots && symbolIdx < tddCfg.nrOfDlSymbols)) + { + cell->slotCfg[slotIdx][symbolIdx] = DL_SYMBOL; + } + + /*Fill Full-FLEXI SLOT and as well as Flexi Symbols in 1 slot preceding FULL-UL slot*/ + else if(slotIdx < (MAX_TDD_PERIODICITY_SLOTS - tddCfg.nrOfUlSlots -1) || \ + (slotIdx == (MAX_TDD_PERIODICITY_SLOTS - tddCfg.nrOfUlSlots -1) && \ + symbolIdx < (MAX_SYMB_PER_SLOT - tddCfg.nrOfUlSymbols))) + { + cell->slotCfg[slotIdx][symbolIdx] = FLEXI_SYMBOL; + } + /*Fill Partial UL symbols and Full-UL slot*/ + else + { + cell->slotCfg[slotIdx][symbolIdx] = UL_SYMBOL; + } + } + } +} /** * @brief init TDD slot config @@ -339,14 +381,15 @@ void schInitTddSlotCfg(SchCellCb *cell, SchCellCfg *schCellCfg) int8_t slotIdx, symbIdx; periodicityInMicroSec = schGetPeriodicityInMsec(schCellCfg->tddCfg.tddPeriod); - cell->numSlotsInPeriodicity = (periodicityInMicroSec * pow(2, schCellCfg->numerology))/1000; + cell->numSlotsInPeriodicity = (periodicityInMicroSec * pow(2, cell->numerology))/1000; cell->slotFrmtBitMap = 0; + schFillSlotConfig(cell, schCellCfg->tddCfg); for(slotIdx = cell->numSlotsInPeriodicity-1; slotIdx >= 0; slotIdx--) { symbIdx = 0; /* If the first and last symbol are the same, the entire slot is the same type */ if((cell->slotCfg[slotIdx][symbIdx] == cell->slotCfg[slotIdx][MAX_SYMB_PER_SLOT-1]) && - cell->slotCfg[slotIdx][symbIdx] != FLEXI_SLOT) + cell->slotCfg[slotIdx][symbIdx] != FLEXI_SYMBOL) { switch(cell->slotCfg[slotIdx][symbIdx]) { @@ -391,7 +434,7 @@ void fillSsbStartSymb(SchCellCb *cellCb) { uint8_t cnt, scs, symbIdx, ssbStartSymbArr[SCH_MAX_SSB_BEAM]; - scs = cellCb->cellCfg.scsCommon; + scs = cellCb->cellCfg.ssbScs; memset(ssbStartSymbArr, 0, sizeof(SCH_MAX_SSB_BEAM)); symbIdx = 0; @@ -453,6 +496,7 @@ void fillSsbStartSymb(SchCellCb *cellCb) **/ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) { + uint16_t scsInKhz = 0; SchCellCb *cell= NULLP; SCH_ALLOC(cell, sizeof(SchCellCb)); if(!cell) @@ -463,7 +507,11 @@ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) cell->cellId = schCellCfg->cellId; cell->instIdx = inst; - switch(schCellCfg->numerology) + scsInKhz = convertScsEnumValToScsVal(schCellCfg->ssbScs); + + /*Ref : 3GPP 38.211 Table 4.2-1: SCS = (2 ^ numerology * 15kHz)*/ + cell->numerology = log2(scsInKhz/BASE_SCS); + switch(cell->numerology) { case SCH_NUMEROLOGY_0: { @@ -491,7 +539,7 @@ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) } break; default: - DU_LOG("\nERROR --> SCH : Numerology %d not supported", schCellCfg->numerology); + DU_LOG("\nERROR --> SCH : Numerology %d not supported", cell->numerology); } #ifdef NR_TDD schInitTddSlotCfg(cell, schCellCfg); @@ -667,13 +715,7 @@ uint8_t fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots,SchPdcchC pdcch->dci.txPdcchPower.powerControlOffsetSS = 0; /* Storing pdschCfg pointer here. Required to access pdsch config while fillig up pdcch pdu */ - SCH_ALLOC(pdcch->dci.pdschCfg, sizeof(PdschCfg)); - if(pdcch->dci.pdschCfg == NULLP) - { - DU_LOG("\nERROR --> SCH : Memory allocation failed in %s ", __func__); - return RFAILED; - } - pdsch = pdcch->dci.pdschCfg; + pdsch = &pdcch->dci.pdschCfg; /* fill the PDSCH PDU */ uint8_t cwCount = 0; @@ -695,7 +737,7 @@ uint8_t fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots,SchPdcchC pdsch->numLayers = 1; pdsch->transmissionScheme = 0; pdsch->refPoint = 0; - pdsch->dmrs.dlDmrsSymbPos = 4; /* Bitmap value 00000000000100 i.e. using 3rd symbol for PDSCH DMRS */ + pdsch->dmrs.dlDmrsSymbPos = DL_DMRS_SYMBOL_POS; pdsch->dmrs.dmrsConfigType = 0; /* type-1 */ pdsch->dmrs.dlDmrsScramblingId = pci; pdsch->dmrs.scid = 0; @@ -758,7 +800,7 @@ uint8_t SchProcCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) cellCb->macInst = pst->srcInst; /* derive the SIB1 config parameters */ - ret = fillSchSib1Cfg(schCellCfg->numerology, schCellCfg->dlBandwidth, cellCb->numSlots, + ret = fillSchSib1Cfg(cellCb->numerology, schCellCfg->dlBandwidth, cellCb->numSlots, &(schCellCfg->pdcchCfgSib1), &(cellCb->sib1SchCfg), schCellCfg->phyCellId, schCellCfg->dlCfgCommon.schFreqInfoDlSib.offsetToPointA, schCellCfg->sib1PduLen); @@ -932,7 +974,6 @@ void deleteSchCellCb(SchCellCb *cellCb) SCH_FREE(cellCb->cellCfg.plmnInfoList[plmnIdx].snssai, cellCb->cellCfg.plmnInfoList[plmnIdx].numSliceSupport*sizeof(Snssai*)); } } - SCH_FREE(cellCb->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg, sizeof(PdschCfg)); for(uint16_t idx =0; idxcellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA; - broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.numPrb -1; + broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.numPrb -1; } else if(ssbOccasion) { @@ -1302,8 +1343,8 @@ uint8_t allocatePrbDl(SchCellCb *cell, SlotTimingInfo slotTime, \ } else if(sib1Occasion) { - broadcastPrbStart = cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.startPrb; - broadcastPrbEnd = broadcastPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.numPrb -1; + broadcastPrbStart = cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.startPrb; + broadcastPrbEnd = broadcastPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.numPrb -1; } /* Iterate through all free PRB blocks */ @@ -1571,7 +1612,7 @@ uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_ { reservedPrbStart = cell->cellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA; reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB + \ - cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.numPrb -1; + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.numPrb -1; } else if(ssbOccasion) { @@ -1580,8 +1621,8 @@ uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_ } else if(sib1Occasion) { - reservedPrbStart = cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.startPrb; - reservedPrbEnd = reservedPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg->pdschFreqAlloc.numPrb -1; + reservedPrbStart = cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.startPrb; + reservedPrbEnd = reservedPrbStart + cell->sib1SchCfg.sib1PdcchCfg.dci.pdschCfg.pdschFreqAlloc.numPrb -1; } else { @@ -1684,150 +1725,105 @@ void SchSendSliceCfgRspToMac(Inst inst, SchSliceCfgRsp sliceCfgRsp) MacMessageRouter(&rspPst, (void *)&sliceCfgRsp); } + /******************************************************************************* * - * @brief fill slice configuration response + * @brief This function is used to store or modify the slice configuration Sch DB * * @details * - * Function : fillSliceCfgRsp + * Function : addOrModifySliceCfgInSchDb * * Functionality: - * fill slice configuration response + * function is used to store or modify the slice configuration Sch DB * - * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t count + * @params[in] SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, + * SchSliceCfgRsp cfgRsp, uint8_t count * * @return * ROK - Success * RFAILED - Failure * * ********************************************************************************/ -uint8_t fillSliceCfgRsp(bool sliceRecfg, SchSliceCfg *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq, SchSliceCfgRsp *schSliceCfgRsp, uint8_t *count) +uint8_t addSliceCfgInSchDb(CmLListCp *sliceCfgInDb, SchRrmPolicyOfSlice *cfgReq) { - bool sliceFound = false; - uint8_t cfgIdx = 0, sliceIdx = 0, plmnIdx = 0; + SchRrmPolicyOfSlice *sliceToStore; - schSliceCfgRsp->numSliceCfgRsp = schSliceCfgReq->numOfConfiguredSlice; - SCH_ALLOC(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*)); - if(schSliceCfgRsp->listOfSliceCfgRsp == NULLP) + SCH_ALLOC(sliceToStore, sizeof(SchRrmPolicyOfSlice)); + if(sliceToStore) { - DU_LOG("\nERROR --> SCH : Memory allocation failed at fillSliceCfgRsp"); - return RFAILED; + memcpy(&sliceToStore->snssai, &cfgReq->snssai, sizeof(Snssai)); + memcpy(&sliceToStore->rrmPolicyRatioInfo, &cfgReq->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); + addNodeToLList(sliceCfgInDb, sliceToStore, NULL); } - - for(cfgIdx = 0; cfgIdxnumSliceCfgRsp ; cfgIdx++) + else { - sliceFound = false; - /* Here comparing the slice cfg request with the slice stored in cellCfg */ - if(sliceRecfg != true) - { - for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++) - { - for(sliceIdx = 0; sliceIdxcellCfg.plmnInfoList[plmnIdx].numSliceSupport; sliceIdx++) - { - if(!memcmp(&schSliceCfgReq->listOfSlices[cfgIdx]->snssai, cellCb->cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], sizeof(Snssai))) - { - (*count)++; - sliceFound = true; - break; - } - } - if(sliceFound == true) - { - break; - } - } - } - else - { - /* Here comparing the slice cfg request with the slice stored in SchDb */ - if(storedSliceCfg->listOfSlices) - { - for(sliceIdx = 0; sliceIdxnumOfSliceConfigured; sliceIdx++) - { - if(!memcmp(&schSliceCfgReq->listOfSlices[cfgIdx]->snssai, &storedSliceCfg->listOfSlices[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->listOfSlices[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; - } + DU_LOG("\nERROR --> SCH : Memory allocation failed in addOrModifySliceCfgInSchDb"); + return RFAILED; } return ROK; } /******************************************************************************* * - * @brief This function is used to store the slice configuration Sch DB + * @brief fill slice configuration response * * @details * - * Function : addSliceCfgInSchDb + * Function : fillSliceCfgRsp * * Functionality: - * function is used to store the slice configuration Sch DB + * fill slice configuration response * - * @params[in] SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, - * SchSliceCfgRsp cfgRsp, uint8_t count + * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t count * * @return * ROK - Success * RFAILED - Failure * * ********************************************************************************/ -uint8_t addSliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, SchSliceCfgRsp cfgRsp, uint8_t count) +uint8_t fillSliceCfgRsp(Inst inst, CmLListCp *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq) { - uint8_t cfgIdx = 0, sliceIdx = 0; - - if(count) - { - storeSliceCfg->numOfSliceConfigured = count; - SCH_ALLOC(storeSliceCfg->listOfSlices, storeSliceCfg->numOfSliceConfigured * sizeof(SchRrmPolicyOfSlice*)); - if(storeSliceCfg->listOfSlices == NULLP) - { - DU_LOG("\nERROR --> SCH : Failed to allocate memory in addSliceCfgInSchDb"); - return RFAILED; - } + SchMacRsp sliceFound; + uint8_t cfgIdx = 0, sliceIdx = 0, plmnIdx = 0, ret =ROK; + SchSliceCfgRsp schSliceCfgRsp; - for(cfgIdx = 0; cfgIdxnumOfSliceConfigured; cfgIdx++) + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + { + sliceFound = RSP_NOK; + /* Here comparing the slice cfg request with the slice stored in cellCfg */ + for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++) { - if(cfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK) + for(sliceIdx = 0; sliceIdxcellCfg.plmnInfoList[plmnIdx].numSliceSupport; sliceIdx++) { - SCH_ALLOC(storeSliceCfg->listOfSlices[sliceIdx], sizeof(SchRrmPolicyOfSlice)); - if(storeSliceCfg->listOfSlices[sliceIdx] == NULLP) + /* If we find the SliceCfgReq's SNSSAI in CellCb's SNSSAI DB, we mark this slice as configured and add it to Sch's DB. */ + if(!memcmp(&schSliceCfgReq->listOfSlices[cfgIdx]->snssai, cellCb->cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], sizeof(Snssai))) { - DU_LOG("\nERROR --> SCH : Failed to allocate memory in addSliceCfgInSchDb"); - return RFAILED; + if(addSliceCfgInSchDb(storedSliceCfg, schSliceCfgReq->listOfSlices[cfgIdx]) == ROK) + { + sliceFound = RSP_OK; + schSliceCfgRsp.cause = SUCCESSFUL; + } + else + { + DU_LOG("\nERROR --> SCH : Failed to store slice configuration in SchDb"); + schSliceCfgRsp.cause = RESOURCE_UNAVAILABLE; + ret = RFAILED; + } + plmnIdx = MAX_PLMN; + break; } - - memcpy(&storeSliceCfg->listOfSlices[sliceIdx]->snssai, &cfgReq->listOfSlices[sliceIdx]->snssai, sizeof(Snssai)); - memcpy(&storeSliceCfg->listOfSlices[sliceIdx]->rrmPolicyRatioInfo, &cfgReq->listOfSlices[sliceIdx]->rrmPolicyRatioInfo, - sizeof(SchRrmPolicyRatio)); - sliceIdx++; } } + + if((sliceFound == RSP_NOK) && (schSliceCfgRsp.cause != RESOURCE_UNAVAILABLE)) + schSliceCfgRsp.cause = SLICE_NOT_FOUND; + + schSliceCfgRsp.snssai = schSliceCfgReq->listOfSlices[cfgIdx]->snssai; + schSliceCfgRsp.rsp = sliceFound; + SchSendSliceCfgRspToMac(inst, schSliceCfgRsp); } - return ROK; + return ret; } /******************************************************************************* @@ -1887,9 +1883,8 @@ void freeSchSliceCfgReq(SchSliceCfgReq *sliceCfgReq) * ********************************************************************************/ uint8_t SchProcSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq) { - uint8_t count = 0; + uint8_t ret = ROK; Inst inst = pst->dstInst - SCH_INST_START; - SchSliceCfgRsp sliceCfgRsp; DU_LOG("\nINFO --> SCH : Received Slice Cfg request from MAC"); if(schSliceCfgReq) @@ -1897,77 +1892,22 @@ uint8_t SchProcSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq) if(schSliceCfgReq->listOfSlices) { /* filling the slice configuration response of each slice */ - if(fillSliceCfgRsp(false, NULLP, schCb[inst].cells[0], schSliceCfgReq, &sliceCfgRsp, &count) != ROK) + if(fillSliceCfgRsp(inst, &schCb[inst].sliceCfg, schCb[inst].cells[0], schSliceCfgReq) != 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; + ret = RFAILED; } freeSchSliceCfgReq(schSliceCfgReq); - SchSendSliceCfgRspToMac(inst, sliceCfgRsp); } } else { DU_LOG("\nERROR --> SCH : Received SchSliceCfgReq is NULL"); + ret = RFAILED; } - return ROK; + return ret; } -/******************************************************************************* - * - * @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->listOfSlices == 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->listOfSlices[sliceIdx]->snssai, &recfgReq->listOfSlices[cfgIdx]->snssai, sizeof(Snssai))) - { - memcpy(&storeSliceCfg->listOfSlices[sliceIdx]->rrmPolicyRatioInfo, &recfgReq->listOfSlices[cfgIdx]->rrmPolicyRatioInfo, - sizeof(SchRrmPolicyRatio)); - break; - } - } - } - } - } - freeSchSliceCfgReq(recfgReq); - return ROK; -} /******************************************************************************* * * @brief This function is used to send Slice re Cfg rsp to MAC @@ -1994,6 +1934,61 @@ void SchSendSliceRecfgRspToMac(Inst inst, SchSliceRecfgRsp schSliceRecfgRsp) MacMessageRouter(&rspPst, (void *)&schSliceRecfgRsp); } + +/******************************************************************************* + * + * @brief fill slice configuration response + * + * @details + * + * Function : fillSliceRecfgRsp + * + * Functionality: fill slice reconfiguration response + * + * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t count + * + * @return + * ROK - Success + * RFAILED - Failure + * + * ********************************************************************************/ + +uint8_t fillSliceRecfgRsp(Inst inst, CmLListCp *storedSliceCfg, SchSliceRecfgReq *schSliceRecfgReq) +{ + SchMacRsp sliceFound; + uint8_t cfgIdx = 0; + SchRrmPolicyOfSlice *rrmPolicyOfSlices; + SchSliceRecfgRsp schSliceRecfgRsp; + + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + { + sliceFound = RSP_NOK; + /* Here comparing the slice recfg request with the StoredSliceCfg */ + CmLList *sliceCfg = storedSliceCfg->first; + + while(sliceCfg) + { + rrmPolicyOfSlices = (SchRrmPolicyOfSlice*)sliceCfg->node; + + if(rrmPolicyOfSlices && (memcmp(&schSliceRecfgReq->listOfSlices[cfgIdx]->snssai, &(rrmPolicyOfSlices->snssai), sizeof(Snssai)) == 0)) + { + memcpy(&rrmPolicyOfSlices->rrmPolicyRatioInfo, &schSliceRecfgReq->listOfSlices[cfgIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio)); + sliceFound = RSP_OK; + break; + } + sliceCfg = sliceCfg->next; + } + + schSliceRecfgRsp.snssai = schSliceRecfgReq->listOfSlices[cfgIdx]->snssai; + schSliceRecfgRsp.rsp = sliceFound; + if(schSliceRecfgRsp.rsp == RSP_OK) + schSliceRecfgRsp.cause = SUCCESSFUL; + else + schSliceRecfgRsp.cause = SLICE_NOT_FOUND; + SchSendSliceRecfgRspToMac(inst, schSliceRecfgRsp); + } + return ROK; +} /******************************************************************************* * * @brief This function is used to store the slice reconfiguration Sch DB @@ -2014,9 +2009,8 @@ void SchSendSliceRecfgRspToMac(Inst inst, SchSliceRecfgRsp schSliceRecfgRsp) * ********************************************************************************/ uint8_t SchProcSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq) { - uint8_t count = 0; + uint8_t ret = ROK; Inst inst = pst->dstInst - SCH_INST_START; - SchSliceRecfgRsp schSliceRecfgRsp; DU_LOG("\nINFO --> SCH : Received Slice ReCfg request from MAC"); if(schSliceRecfgReq) @@ -2024,26 +2018,20 @@ uint8_t SchProcSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq) if(schSliceRecfgReq->listOfSlices) { /* filling the slice configuration response of each slice */ - if(fillSliceCfgRsp(true, &schCb[inst].sliceCfg, NULLP, schSliceRecfgReq, &schSliceRecfgRsp, &count) != ROK) + if(fillSliceRecfgRsp(inst, &schCb[inst].sliceCfg, schSliceRecfgReq) != ROK) { DU_LOG("\nERROR --> SCH : Failed to fill sch slice cfg response"); - return RFAILED; + ret = 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); + freeSchSliceCfgReq(schSliceRecfgReq); } } else { DU_LOG("\nERROR --> SCH : Received SchSliceRecfgReq is NULL"); + } - return ROK; + return ret; } /**************************************************************************** @@ -2351,6 +2339,201 @@ RgMngmt *cfm return; } +/******************************************************************* + * + * @brief Processes DL CQI ind from MAC + * + * @details + * + * Function : SchProcDlCqiInd + * + * Functionality: + * Processes DL CQI ind from MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcDlCqiInd(Pst *pst, SchDlCqiInd *dlCqiInd) +{ + uint8_t ret = ROK; + uint16_t ueId = 0, cellIdx = 0; + SchUeCb *ueCb = NULLP; + SchCellCb *cell = NULLP; + Inst inst = pst->dstInst-SCH_INST_START; + + if(!dlCqiInd) + { + DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): CQI Ind is empty"); + ret = RFAILED; + } + else + { + GET_CELL_IDX(dlCqiInd->cellId, cellIdx); + cell = schCb[inst].cells[cellIdx]; + if(cell == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): cell Id[%d] not found", dlCqiInd->cellId); + ret = RFAILED; + } + else + { + if(cell->cellId == dlCqiInd->cellId) + { + GET_UE_ID(dlCqiInd->crnti, ueId); + ueCb = &cell->ueCb[ueId-1]; + if(ueCb->crnti != dlCqiInd->crnti) + { + DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): UeCb for received crnti[%d] not found", dlCqiInd->crnti); + ret = RFAILED; + } + else + { + /*TODO: complete the processing of DL CQI Ind*/ + } + } + else + { + DU_LOG("\nERROR --> SCH : SchProcDlCqiInd(): Received cell Id[%d] from MAC is not matching with CellID[%d] in SCH Cb",\ + dlCqiInd->cellId, cell->cellId); + ret = RFAILED; + } + } + } + return ret; +} + +/******************************************************************* + * + * @brief Processes UL CQI ind from MAC + * + * @details + * + * Function : SchProcUlCqiInd + * + * Functionality: + * Processes UL CQI ind from MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcUlCqiInd(Pst *pst, SchUlCqiInd *ulCqiInd) +{ + uint8_t ret = ROK; + uint16_t ueId = 0, cellIdx = 0; + SchUeCb *ueCb = NULLP; + SchCellCb *cell = NULLP; + Inst inst = pst->dstInst-SCH_INST_START; + + if(!ulCqiInd) + { + DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): CQI Ind is empty"); + ret = RFAILED; + } + else + { + GET_CELL_IDX(ulCqiInd->cellId, cellIdx); + cell = schCb[inst].cells[cellIdx]; + if(cell == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): cell Id[%d] not found", ulCqiInd->cellId); + ret = RFAILED; + } + else + { + if(cell->cellId == ulCqiInd->cellId) + { + GET_UE_ID(ulCqiInd->crnti, ueId); + ueCb = &cell->ueCb[ueId-1]; + if(ueCb->crnti != ulCqiInd->crnti) + { + DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): UeCb for received crnti[%d] not found",ulCqiInd->crnti); + ret = RFAILED; + } + else + { + /*TODO: complete the processing of UL CQI Ind*/ + } + } + else + { + DU_LOG("\nERROR --> SCH : SchProcUlCqiInd(): Received cell Id[%d] from MAC is not matching with CellId[%d] in SCH Cb",\ + ulCqiInd->cellId, cell->cellId); + ret = RFAILED; + } + } + } + return ret; +} + +/******************************************************************* + * + * @brief Processes PHR ind from MAC + * + * @details + * + * Function : SchProcPhrInd + * + * Functionality: + * Processes PHR ind from MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcPhrInd(Pst *pst, SchPwrHeadroomInd *schPhrInd) +{ + uint8_t ret = ROK; + uint16_t ueId = 0, cellIdx = 0; + SchUeCb *ueCb = NULLP; + SchCellCb *cell = NULLP; + Inst inst = pst->dstInst-SCH_INST_START; + + if(!schPhrInd) + { + DU_LOG("\nERROR --> SCH : SchProcPhrInd(): PHR is empty"); + ret = RFAILED; + } + else + { + GET_CELL_IDX(schPhrInd->cellId, cellIdx); + cell = schCb[inst].cells[cellIdx]; + if(cell == NULLP) + { + DU_LOG("\nERROR --> SCH : schProcPhrInd(): cell Id[%d] is not found", schPhrInd->cellId); + ret = RFAILED; + } + else + { + if(cell->cellId == schPhrInd->cellId) + { + GET_UE_ID(schPhrInd->crnti, ueId); + ueCb = &cell->ueCb[ueId-1]; + if(ueCb->crnti != schPhrInd->crnti) + { + DU_LOG("\nERROR --> SCH : SchProcPhrInd(): UeCb for received crnti[%d] not found",schPhrInd->crnti); + ret = RFAILED; + } + else + { + /*TODO: complete the processing of PHR Ind*/ + } + } + else + { + DU_LOG("\nERROR --> SCH : SchProcPhrInd(): Mismatch between Received cell Id[%d] from MAC and CellID[%d] in SCH CB ",\ + schPhrInd->cellId, cell->cellId); + ret = RFAILED; + } + } + } + return ret; +} + /********************************************************************** End of file **********************************************************************/