X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Fsch_rach.c;h=162ed15f6409ca457c4eac9ae6f9872dfdf4d83b;hb=2bd852089c3226f721d83b30f816b90f803237f6;hp=2e0527c7cde746597d83be27a224f4efa9a91f46;hpb=af8f9c8f6f7cd5e0a89e5dfa7a566fa5811e110c;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch_rach.c b/src/5gnrsch/sch_rach.c index 2e0527c7c..162ed15f6 100644 --- a/src/5gnrsch/sch_rach.c +++ b/src/5gnrsch/sch_rach.c @@ -42,6 +42,13 @@ #include "sch.h" #include "sch_utils.h" +SchRachRsrcRspFunc SchRachRsrcRspOpts[] = +{ + packSchRachRsrcRsp, /* LC */ + MacProcSchRachRsrcRsp, /* TC */ + packSchRachRsrcRsp /* LWLC */ +}; + /** * @brief Checks if PRACH can be scheduled in current slot * @@ -109,7 +116,7 @@ bool schCheckPrachOcc(SchCellCb *cell, SlotTimingInfo prachOccasionTimingInfo) uint8_t schCalcPrachNumRb(SchCellCb *cell) { uint8_t tableIdx = 0; - uint16_t puschScs = fetchScsValue(cell->cellCfg.schInitialUlBwp.bwp.scs); + uint16_t puschScs = convertScsEnumValToScsVal(cell->cellCfg.schInitialUlBwp.bwp.scs); for(tableIdx=0; tableIdx < MAX_RACH_NUM_RB_IDX; tableIdx++) { @@ -184,6 +191,153 @@ void schPrachResAlloc(SchCellCb *cell, UlSchedInfo *ulSchedInfo, SlotTimingInfo DU_LOG("\nINFO --> SCH : RACH occassion set for slot %d", prachOccasionTimingInfo.slot); } +/** + * @brief Process RACH resource request for CFRA + * + * @details + * + * Function : MacSchRachRsrcReq + * + * This function processes RACH resorce request + * from MAC for CFRA. It assigns a dedicated preamble + * to the UE and sends the same in RACH resource + * response + * + * @param[in] Post structure + * @param[in] RACH resource request + * @return ROK + * RFAILED + **/ +uint8_t MacSchRachRsrcReq(Pst *pst, SchRachRsrcReq *schRachRsrcReq) +{ + uint8_t ssbIdx = 0, cfraSsbIdx = 0; + uint8_t firstCFPreambleIndex = 0, lastCFPreambleIndex = 0; + uint16_t cellIdx = 0; + uint64_t mask = 0; + Pst rspPst; + Inst inst = pst->dstInst - SCH_INST_START; + SchCellCb *cellCb = NULLP; + SchUeCb *ueCb = NULLP; + SchRachRsrcRsp *rachRsrcRsp = NULLP; + + DU_LOG("\nINFO --> SCH : Received RACH resource request for Cell ID [%d] CRNTI [%d]", \ + schRachRsrcReq->cellId, schRachRsrcReq->crnti); + + /* Fill RACH resource response to MAC */ + SCH_ALLOC(rachRsrcRsp, sizeof(SchRachRsrcRsp)); + if(!rachRsrcRsp) + { + DU_LOG("\nERROR --> SCH : Memory allocation failed for RACH resource response"); + return RFAILED; + } + rachRsrcRsp->cellId = schRachRsrcReq->cellId; + rachRsrcRsp->crnti = schRachRsrcReq->crnti; + rachRsrcRsp->result = RSP_OK; + + /* Fill SCH to MAC Pst structure */ + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_SCH_TO_MAC(rspPst, inst); + rspPst.event = EVENT_RACH_RESOURCE_RESPONSE_TO_MAC; + + /* Fetch Cell CB */ + for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++) + { + if((schCb[inst].cells[cellIdx]) && (schCb[inst].cells[cellIdx]->cellId == schRachRsrcReq->cellId)) + { + cellCb = schCb[inst].cells[cellIdx]; + break; + } + } + + if(cellCb) + { + /* Fetch UE CB */ + ueCb = schGetUeCb(cellCb, schRachRsrcReq->crnti); + if(ueCb->crnti != schRachRsrcReq->crnti) + { + DU_LOG("\nERROR --> SCH : CRNTI [%d] not found" ,schRachRsrcReq->crnti); + rachRsrcRsp->result = RSP_NOK; + } + } + else + { + DU_LOG("\nERROR --> SCH : Cell ID [%d] not found" ,schRachRsrcReq->cellId); + rachRsrcRsp->result = RSP_NOK; + } + + /* Allocate SSB resource if no failure has occurred until this step */ + if(rachRsrcRsp->result == RSP_OK) + { + /* Find first free preamble index from the pool CF preambles + * Preamble index from 0 to (numCbPreamblePerSsb-1) is used for CBRA + * Preamble index from numCbPreamblePerSsb to totalNumOfRAPreamble + * is used for CFRA */ + firstCFPreambleIndex = cellCb->cellCfg.schRachCfg.numCbPreamblePerSsb; + lastCFPreambleIndex = cellCb->cellCfg.schRachCfg.totalNumRaPreamble; + + /* Allocate resource for each SSB index requested */ + for(ssbIdx = 0; ssbIdx < schRachRsrcReq->numSsb; ssbIdx++) + { + /* Find the first CF Preamble index not dedicated to any UE currently */ + while(firstCFPreambleIndex <= lastCFPreambleIndex) + { + mask = 1 << firstCFPreambleIndex; + if(cellCb->dedPreambleBitMap & mask) + { + firstCFPreambleIndex++; + continue; + } + else + break; + } + + /* If firstCFPreambleIndex > lastCFPreambleIndex, it means all + * dedicated preambles are in use currently. In such a case, CBRA + * should be initiated. + * If a dedicated preamble is found, use this for CFRA and mark it as + * IN-USE in the bitmap. + * Considering only CFRA scenario for now. */ + if(firstCFPreambleIndex <= lastCFPreambleIndex) + { + ueCb->cfraResource.ssbResource[cfraSsbIdx].ssbIdx = schRachRsrcReq->ssbIdx[ssbIdx]; + ueCb->cfraResource.ssbResource[cfraSsbIdx].raPreambleIdx = firstCFPreambleIndex; + SET_ONE_BIT(firstCFPreambleIndex, cellCb->dedPreambleBitMap); + cfraSsbIdx++; + firstCFPreambleIndex++; + } + else + { + DU_LOG("\nINFO : SCH : No dedicated preameble availble to assign to ssbIdx[%d]", schRachRsrcReq->ssbIdx[ssbIdx]); + /* Breaking out of for loop since no dedicated preambles are available + * for remaining ssbIdx too */ + break; + } + } /* End of for */ + + ueCb->cfraResource.numSsb = cfraSsbIdx; + + if(ueCb->cfraResource.numSsb == 0) + { + /* If numSsb is 0, it means no CFRA resource was alloacted for any of the + * SSB Idx, hence send a negative response */ + rachRsrcRsp->result = RSP_NOK; + } + else + { + /* Send ssb resource information to MAC in RACH resource response */ + rachRsrcRsp->cfraResource.numSsb = ueCb->cfraResource.numSsb; + memcpy(rachRsrcRsp->cfraResource.ssbResource, ueCb->cfraResource.ssbResource, \ + ueCb->cfraResource.numSsb * sizeof(SchCfraSsbResource)); + } + } /* End of if */ + + /* Free RACH resource request memory allocated by MAC */ + SCH_FREE(schRachRsrcReq, sizeof(SchRachRsrcReq)); + + /* Send RACH resource response to MAC */ + return (SchRachRsrcRspOpts[rspPst.selector](&rspPst, rachRsrcRsp)); +} + /** * @brief calculate ra-rnti function. * @@ -217,17 +371,35 @@ uint16_t calculateRaRnti(uint8_t symbolIdx, uint8_t slotIdx, uint8_t freqIdx) * * This function create raCb * - * @param[in] tcrnti + * @param[in] crnti * @param[in] shed instance * @return void **/ -void createSchRaCb(uint16_t tcrnti, Inst schInst) +void createSchRaCb(SchRaReq *raReq, Inst schInst) { - uint8_t ueIdx = 0; + uint8_t ueId = 0; - GET_UE_IDX(tcrnti, ueIdx); - schCb[schInst].cells[schInst]->raCb[ueIdx -1].tcrnti = tcrnti; - schCb[schInst].cells[schInst]->raCb[ueIdx -1].msg4recvd = FALSE; + if(raReq->isCFRA) + { + /* If a UE in handover has triggered CFRA, its UE CB context is already present in SCH, + * Hence, no need to create raCb */ + if(raReq->ueCb && (raReq->ueCb->state == SCH_UE_HANDIN_IN_PROGRESS)) + { + schCb[schInst].cells[schInst]->numActvUe++; + SET_ONE_BIT(raReq->ueCb->ueId, schCb[schInst].cells[schInst]->actvUeBitMap); + raReq->ueCb->state = SCH_UE_STATE_ACTIVE; + schCb[schInst].cells[schInst]->raCb[ueId -1].raState = SCH_RA_STATE_MSG4_DONE; + } + } + else + { + /* Create RA CB only for CB-RA to use for msg3 and msg4 processing */ + GET_UE_ID(raReq->rachInd->crnti, ueId); + schCb[schInst].cells[schInst]->raCb[ueId -1].tcrnti = raReq->rachInd->crnti; + schCb[schInst].cells[schInst]->raCb[ueId -1].msg4recvd = FALSE; + schCb[schInst].cells[schInst]->raCb[ueId -1].raState = SCH_RA_STATE_MSG3_PENDING; + } + schCb[schInst].cells[schInst]->raCb[ueId -1].cell = schCb[schInst].cells[schInst]; } /** @@ -245,7 +417,7 @@ void createSchRaCb(uint16_t tcrnti, Inst schInst) * @param[out] msg3NumRb * @return void **/ -SchPuschInfo* schAllocMsg3Pusch(Inst schInst, uint16_t crnti, uint8_t k2Index, SlotTimingInfo msg3SlotTime) +SchPuschInfo* schAllocMsg3Pusch(Inst schInst, uint16_t crnti, uint8_t k2Index, SlotTimingInfo msg3SlotTime, SchUlHqProcCb* msg3HqProc, bool isRetx) { SchCellCb *cell = NULLP; SchUlSlotInfo *schUlSlotInfo = NULLP; @@ -287,7 +459,7 @@ SchPuschInfo* schAllocMsg3Pusch(Inst schInst, uint16_t crnti, uint8_t k2Index, S tbSize = tbSize / 8 ; /*bits to byte conversion*/ schUlSlotInfo->schPuschInfo->crnti = crnti; - schUlSlotInfo->schPuschInfo->harqProcId = SCH_HARQ_PROC_ID; + schUlSlotInfo->schPuschInfo->harqProcId = msg3HqProc->procId; schUlSlotInfo->schPuschInfo->resAllocType = SCH_ALLOC_TYPE_1; schUlSlotInfo->schPuschInfo->fdAlloc.startPrb = startRb; schUlSlotInfo->schPuschInfo->fdAlloc.numPrb = numRb; @@ -302,7 +474,23 @@ SchPuschInfo* schAllocMsg3Pusch(Inst schInst, uint16_t crnti, uint8_t k2Index, S schUlSlotInfo->schPuschInfo->dmrsMappingType = DMRS_MAP_TYPE_A; /* Setting Type-A */ schUlSlotInfo->schPuschInfo->nrOfDmrsSymbols = NUM_DMRS_SYMBOLS; schUlSlotInfo->schPuschInfo->dmrsAddPos = DMRS_ADDITIONAL_POS; - + if(!isRetx) + { + msg3HqProc->strtSymbl = startSymb; + msg3HqProc->numSymbl = symbLen; + msg3HqProc->puschResType = schUlSlotInfo->schPuschInfo->resAllocType; + msg3HqProc->puschStartPrb = schUlSlotInfo->schPuschInfo->fdAlloc.startPrb; + msg3HqProc->puschNumPrb = schUlSlotInfo->schPuschInfo->fdAlloc.numPrb; + msg3HqProc->tbInfo.qamOrder = schUlSlotInfo->schPuschInfo->tbInfo.qamOrder; + msg3HqProc->tbInfo.iMcs = schUlSlotInfo->schPuschInfo->tbInfo.mcs; + msg3HqProc->tbInfo.mcsTable = schUlSlotInfo->schPuschInfo->tbInfo.mcsTable; + msg3HqProc->tbInfo.ndi = schUlSlotInfo->schPuschInfo->tbInfo.ndi; + msg3HqProc->tbInfo.rv = schUlSlotInfo->schPuschInfo->tbInfo.rv; + msg3HqProc->tbInfo.tbSzReq = schUlSlotInfo->schPuschInfo->tbInfo.tbSize; + msg3HqProc->dmrsMappingType = schUlSlotInfo->schPuschInfo->dmrsMappingType; + msg3HqProc->nrOfDmrsSymbols = schUlSlotInfo->schPuschInfo->nrOfDmrsSymbols; + msg3HqProc->dmrsAddPos = schUlSlotInfo->schPuschInfo->dmrsAddPos; + } return schUlSlotInfo->schPuschInfo; } @@ -350,34 +538,38 @@ RaRspWindowStatus isInRaRspWindow(SchRaReq *raReq, SlotTimingInfo frameToCheck, * @param[in] Current timing of the cell * @return ROK **/ -bool schProcessRaReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId) +bool schProcessRaReq(Inst schInst, SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId) { - bool k2Found = false; - uint8_t k0TblIdx = 0, k2TblIdx = 0; - uint8_t k0Index = 0, k2Index = 0; - uint8_t k0 = 0, k2 = 0; + bool k1Found = false, k2Found = false; + uint8_t k0TblIdx = 0, k1TblIdx = 0, k2TblIdx = 0; + uint8_t k0Index = 0, k1Index = 0, k2Index = 0; + uint8_t k0 = 0, k1 = 0, k2 = 0; + uint8_t numK1 = 0; uint8_t puschMu = 0; uint8_t msg3Delta = 0, msg3MinSchTime = 0; #ifdef NR_TDD uint8_t totalCfgSlot = 0; #endif uint16_t dciSlot = 0, rarSlot = 0; - SlotTimingInfo dciTime, rarTime, msg3Time; + SlotTimingInfo dciTime, rarTime, msg3Time, pucchTime; RarAlloc *dciSlotAlloc = NULLP; /* Stores info for transmission of PDCCH for RAR */ RarAlloc *rarSlotAlloc = NULLP; /* Stores info for transmission of RAR PDSCH */ SchPuschInfo *msg3PuschInfo = NULLP; /* Stores MSG3 PUSCH scheduling information */ SchK0K1TimingInfoTbl *k0K1InfoTbl=NULLP; SchK2TimingInfoTbl *msg3K2InfoTbl=NULLP; RaRspWindowStatus windowStatus=0; - + #ifdef NR_TDD totalCfgSlot = calculateSlotPatternLength(cell->cellCfg.ssbSchCfg.scsCommon, cell->cellCfg.tddCfg.tddPeriod); #endif - k0K1InfoTbl = &cell->cellCfg.schInitialDlBwp.k0K1InfoTbl; - msg3K2InfoTbl = &cell->cellCfg.schInitialUlBwp.msg3K2InfoTbl; - puschMu = cell->cellCfg.numerology; - msg3Delta = puschDeltaTable[puschMu]; - msg3MinSchTime = minMsg3SchTime[cell->cellCfg.numerology]; + k0K1InfoTbl = &cell->cellCfg.schInitialDlBwp.k0K1InfoTbl; + if(cell->raReq[ueId-1]->isCFRA == false) + { + msg3K2InfoTbl = &cell->cellCfg.schInitialUlBwp.msg3K2InfoTbl; + puschMu = cell->cellCfg.numerology; + msg3Delta = puschDeltaTable[puschMu]; + msg3MinSchTime = minMsg3SchTime[cell->cellCfg.numerology]; + } /* Calculating time frame to send DCI for RAR */ ADD_DELTA_TO_TIME(currTime, dciTime, PHY_DELTA_DL + SCHED_DELTA); @@ -412,30 +604,63 @@ bool schProcessRaReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId) if(cell->schDlSlotInfo[rarSlot]->pdschUe != 0) continue; - for(k2TblIdx = 0; k2TblIdx < msg3K2InfoTbl->k2TimingInfo[rarSlot].numK2; k2TblIdx++) + /* If Contention-FREE RA is in progress, allocate resources for + * PUCCH for next UL message */ + if(cell->raReq[ueId-1]->isCFRA) { - k2Index = msg3K2InfoTbl->k2TimingInfo[rarSlot].k2Indexes[k2TblIdx]; - k2 = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].k2; - - /* Delta is added to the slot allocation for msg3 based on 38.214 section 6.1.2.1 */ - k2 = k2 + msg3Delta; - if(k2 >= msg3MinSchTime) - { - ADD_DELTA_TO_TIME(rarTime, msg3Time, k2); + numK1 = k0K1InfoTbl->k0k1TimingInfo[dciTime.slot].k0Indexes[k0TblIdx].k1TimingInfo.numK1; + for(k1TblIdx = 0; k1TblIdx < numK1; k1TblIdx++) + { + k1Index = k0K1InfoTbl->k0k1TimingInfo[dciTime.slot].k0Indexes[k0TblIdx].k1TimingInfo.k1Indexes[k1TblIdx]; + if(cell->raReq[ueId-1]->ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfg.dlDataToUlAck) + { + k1 = cell->raReq[ueId-1]->ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfg.dlDataToUlAck->\ + dlDataToUlAckList[k1Index]; + } + else + { + k1 = defaultUlAckTbl[k1Index]; + } + + ADD_DELTA_TO_TIME(rarTime, pucchTime, k1); #ifdef NR_TDD - if(schGetSlotSymbFrmt(msg3Time.slot % totalCfgSlot, cell->slotFrmtBitMap) == DL_SLOT) + if(schGetSlotSymbFrmt(pucchTime.slot, cell->slotFrmtBitMap) == DL_SLOT) continue; #endif - /* If PUSCH is already scheduled on this slot, another PUSCH - * pdu cannot be scheduled here */ - if(cell->schUlSlotInfo[msg3Time.slot]->puschUe != 0) + if(cell->schUlSlotInfo[pucchTime.slot]->pucchUe != 0) continue; - - k2Found = true; + k1Found = true; break; } } - if(k2Found) + else + { + /* Else if contention-based RA is in progress, allocate resources for MSG3 */ + for(k2TblIdx = 0; k2TblIdx < msg3K2InfoTbl->k2TimingInfo[rarSlot].numK2; k2TblIdx++) + { + k2Index = msg3K2InfoTbl->k2TimingInfo[rarSlot].k2Indexes[k2TblIdx]; + k2 = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].k2; + + /* Delta is added to the slot allocation for msg3 based on 38.214 section 6.1.2.1 */ + k2 = k2 + msg3Delta; + if(k2 >= msg3MinSchTime) + { + ADD_DELTA_TO_TIME(rarTime, msg3Time, k2); +#ifdef NR_TDD + if(schGetSlotSymbFrmt(msg3Time.slot % totalCfgSlot, cell->slotFrmtBitMap) == DL_SLOT) + continue; +#endif + /* If PUSCH is already scheduled on this slot, another PUSCH + * pdu cannot be scheduled here */ + if(cell->schUlSlotInfo[msg3Time.slot]->puschUe != 0) + continue; + + k2Found = true; + break; + } + } + } + if(k1Found || k2Found) break; } } @@ -446,8 +671,8 @@ bool schProcessRaReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId) return false; } - /* If K0-K2 combination not found, no scheduling happens */ - if(!k2Found) + /* If K0-K2 and K0-K1 combination not found, no scheduling happens */ + if(!k1Found && !k2Found) return false; /* Allocate memory for RAR PDCCH slot, pointer will be checked at schProcessSlotInd() */ @@ -468,26 +693,35 @@ bool schProcessRaReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId) return false; } - /* Allocate resources for msg3 */ - msg3PuschInfo = schAllocMsg3Pusch(cell->instIdx, cell->raReq[ueId-1]->rachInd->crnti, k2Index, msg3Time); - if(msg3PuschInfo) + /* Fill RAR info */ + dciSlotAlloc->rarInfo.raRnti = cell->raReq[ueId-1]->raRnti; + dciSlotAlloc->rarInfo.tcrnti = cell->raReq[ueId-1]->rachInd->crnti; + dciSlotAlloc->rarInfo.RAPID = cell->raReq[ueId-1]->rachInd->preambleIdx; + dciSlotAlloc->rarInfo.ta = cell->raReq[ueId-1]->rachInd->timingAdv; + + if(cell->raReq[ueId-1]->isCFRA) { - /* Fill RAR info */ - dciSlotAlloc->rarInfo.raRnti = cell->raReq[ueId-1]->raRnti; - dciSlotAlloc->rarInfo.tcrnti = cell->raReq[ueId-1]->rachInd->crnti; - dciSlotAlloc->rarInfo.RAPID = cell->raReq[ueId-1]->rachInd->preambleIdx; - dciSlotAlloc->rarInfo.ta = cell->raReq[ueId-1]->rachInd->timingAdv; - dciSlotAlloc->rarInfo.ulGrant.bwpSize = cell->cellCfg.schInitialUlBwp.bwp.freqAlloc.numPrb; - /* Spec 38.213, section 8.2, 0 : MSG3 PUSCH will be transmitted without frequency hopping */ - dciSlotAlloc->rarInfo.ulGrant.freqHopFlag = 0; - dciSlotAlloc->rarInfo.ulGrant.msg3FreqAlloc.startPrb = msg3PuschInfo->fdAlloc.startPrb; - dciSlotAlloc->rarInfo.ulGrant.msg3FreqAlloc.numPrb = msg3PuschInfo->fdAlloc.numPrb; - dciSlotAlloc->rarInfo.ulGrant.k2Index = k2Index; - dciSlotAlloc->rarInfo.ulGrant.mcs = msg3PuschInfo->tbInfo.mcs; - dciSlotAlloc->rarInfo.ulGrant.tpc = 3; /* TODO : Check appropriate value to be filled */ - /* Spec 38.213, section 8.2 : In a contention based random access - * procedure, the CSI request field is reserved. */ - dciSlotAlloc->rarInfo.ulGrant.csiReq = 0; + /* Allocate resources for PUCCH */ + schAllocPucchResource(cell, pucchTime, cell->raReq[ueId-1]->rachInd->crnti,NULLP, FALSE, NULLP); + } + else + { + /* Allocate resources for msg3 */ + msg3PuschInfo = schAllocMsg3Pusch(schInst, cell->raReq[ueId-1]->rachInd->crnti, k2Index, msg3Time, &(cell->raCb[ueId-1].msg3HqProc), FALSE); + if(msg3PuschInfo) + { + dciSlotAlloc->rarInfo.ulGrant.bwpSize = cell->cellCfg.schInitialUlBwp.bwp.freqAlloc.numPrb; + /* Spec 38.213, section 8.2, 0 : MSG3 PUSCH will be transmitted without frequency hopping */ + dciSlotAlloc->rarInfo.ulGrant.freqHopFlag = 0; + dciSlotAlloc->rarInfo.ulGrant.msg3FreqAlloc.startPrb = msg3PuschInfo->fdAlloc.startPrb; + dciSlotAlloc->rarInfo.ulGrant.msg3FreqAlloc.numPrb = msg3PuschInfo->fdAlloc.numPrb; + dciSlotAlloc->rarInfo.ulGrant.k2Index = k2Index; + dciSlotAlloc->rarInfo.ulGrant.mcs = msg3PuschInfo->tbInfo.mcs; + dciSlotAlloc->rarInfo.ulGrant.tpc = 3; /* TODO : Check appropriate value to be filled */ + /* Spec 38.213, section 8.2 : In a contention based random access + * procedure, the CSI request field is reserved. */ + dciSlotAlloc->rarInfo.ulGrant.csiReq = 0; + } } /* Check if both DCI and RAR are sent in the same slot. @@ -520,10 +754,13 @@ bool schProcessRaReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId) cell->schDlSlotInfo[dciSlot]->pdcchUe = ueId; cell->schDlSlotInfo[rarSlot]->pdschUe = ueId; - cell->schUlSlotInfo[msg3Time.slot]->puschUe = ueId; + if(cell->raReq[ueId-1]->isCFRA) + cell->schUlSlotInfo[pucchTime.slot]->pucchUe = ueId; + else + cell->schUlSlotInfo[msg3Time.slot]->puschUe = ueId; /* Create raCb at SCH */ - createSchRaCb(cell->raReq[ueId-1]->rachInd->crnti, cell->instIdx); + createSchRaCb(cell->raReq[ueId-1], schInst); /* Remove RachInd from pending RA request list */ SCH_FREE(cell->raReq[ueId-1]->rachInd, sizeof(RachIndInfo)); @@ -553,7 +790,7 @@ uint8_t schProcessRachInd(RachIndInfo *rachInd, Inst schInst) SchRaReq *raReq = NULLP; float slotDuration; uint8_t winNumSlots; - uint8_t ueIdx; + uint8_t ueId; if(cell == NULLP) { @@ -562,8 +799,8 @@ uint8_t schProcessRachInd(RachIndInfo *rachInd, Inst schInst) } /* Storing RA request in cellCb */ - GET_UE_IDX(rachInd->crnti, ueIdx); - if(ueIdx <= 0) + GET_UE_ID(rachInd->crnti, ueId); + if(ueId <= 0) { DU_LOG("\nERROR --> SCH: Invalid CRNTI [%d]", rachInd->crnti); return RFAILED; @@ -580,6 +817,13 @@ uint8_t schProcessRachInd(RachIndInfo *rachInd, Inst schInst) /* calculate the ra-rnti value */ raReq->raRnti = calculateRaRnti(rachInd->symbolIdx, rachInd->slotIdx, rachInd->freqIdx); raReq->rachInd = rachInd; + if((cell->ueCb[ueId-1].crnti == rachInd->crnti) && (cell->ueCb[ueId-1].state == SCH_UE_HANDIN_IN_PROGRESS)) + { + raReq->isCFRA = true; + raReq->ueCb = &cell->ueCb[ueId-1]; + } + else + raReq->isCFRA = false; raReq->winStartTime.sfn = rachInd->timingInfo.sfn; raReq->winStartTime.slot = rachInd->timingInfo.slot; @@ -589,10 +833,10 @@ uint8_t schProcessRachInd(RachIndInfo *rachInd, Inst schInst) /* Adding window size to window start time to get window end time */ ADD_DELTA_TO_TIME(raReq->winStartTime, raReq->winEndTime, winNumSlots); - cell->raReq[ueIdx -1] = raReq; + cell->raReq[ueId -1] = raReq; /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cell, ueIdx); + addUeToBeScheduled(cell, ueId); return ROK; } @@ -752,6 +996,101 @@ uint8_t schFillRar(SchCellCb *cell, SlotTimingInfo rarTime, uint16_t ueId, RarAl return ROK; } + /* @brief Process RACH resource release after CFRA + * + * @details + * + * Function : MacSchRachRsrcRel + * + * This function processes RACH resorce release + * from MAC after CFRA. It releases the dedicated + * preamble alloted to the UE + * + * @param[in] Post structure + * @param[in] RACH resource release + * @return ROK + * RFAILED + */ +uint8_t MacSchRachRsrcRel(Pst *pst, SchRachRsrcRel *schRachRsrcRel) +{ + uint8_t ret = ROK; + uint8_t ssbIdx = 0, cfraSsbIdx = 0; + uint16_t cellIdx = 0; + Inst inst = pst->dstInst - SCH_INST_START; + SchCellCb *cellCb = NULLP; + SchUeCb *ueCb = NULLP; + + DU_LOG("\nINFO --> SCH : Received RACH resource release for Cell ID [%d] CRNTI [%d]", \ + schRachRsrcRel->cellId, schRachRsrcRel->crnti); + + /* Fetch Cell CB */ + for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++) + { + if((schCb[inst].cells[cellIdx]) && (schCb[inst].cells[cellIdx]->cellId == schRachRsrcRel->cellId)) + { + cellCb = schCb[inst].cells[cellIdx]; + break; + } + } + + if(cellCb) + { + /* Fetch UE CB */ + ueCb = schGetUeCb(cellCb, schRachRsrcRel->crnti); + if(ueCb->crnti != schRachRsrcRel->crnti) + { + DU_LOG("\nERROR --> SCH : CRNTI [%d] not found", schRachRsrcRel->crnti); + ret = RFAILED; + } + } + else + { + DU_LOG("\nERROR --> SCH : Cell ID [%d] not found", schRachRsrcRel->cellId); + ret = RFAILED; + } + + /* Free SSB resource if no failure has occurred until this step */ + if(ret == ROK) + { + for(ssbIdx = 0; ssbIdx < schRachRsrcRel->cfraResource.numSsb; ssbIdx++) + { + /* Search each ssbIdx entry in UE Cb */ + for(cfraSsbIdx = 0; cfraSsbIdx < ueCb->cfraResource.numSsb; cfraSsbIdx++) + { + if(ueCb->cfraResource.ssbResource[cfraSsbIdx].ssbIdx == schRachRsrcRel->cfraResource.ssbResource[ssbIdx].ssbIdx) + { + /* If ssbIdx entry is found in UE CB, free dedicated resources + * for this ssbIdx */ + UNSET_ONE_BIT(ueCb->cfraResource.ssbResource[cfraSsbIdx].raPreambleIdx, cellCb->dedPreambleBitMap); + memset(&ueCb->cfraResource.ssbResource[cfraSsbIdx], 0, sizeof(SchCfraSsbResource)); + ueCb->cfraResource.numSsb--; + break; + } + } + } /* End of for */ + } /* End of if */ + + /* Free RACH resource release memory allocated by MAC */ + SCH_FREE(schRachRsrcRel, sizeof(SchRachRsrcRel)); + return ret; +} + /* @brief process MSG4 completion + * + * @details + * + * Function : schMsg4Complete + * + * This function updates ra state and msg4 Hqrq + * proc upon MSG4 completion + * @param[in] SchUeCb *ueCb, UE cb pointer + * @return VOID + */ +void schMsg4Complete(SchUeCb *ueCb) +{ + DU_LOG("\nINFO --> SCH: State change for ueId[%2d] to SCH_RA_STATE_MSG4_DONE\n",ueCb->ueId); + ueCb->cellCb->raCb[ueCb->ueId-1].raState = SCH_RA_STATE_MSG4_DONE; + ueCb->msg4Proc = ueCb->retxMsg4HqProc = NULLP; +} /********************************************************************** End of file **********************************************************************/