1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
19 /************************************************************************
25 Desc: C source code for Entry point fucntions
29 **********************************************************************/
31 /** @file rg_sch_uhm.c
32 @brief This module handles uplink harq related functionality in MAC.
35 /* header include files -- defines (.h) */
36 #include "common_def.h"
37 #include "rg_env.h" /* MAC Environment Defines */
38 #include "tfu.h" /* TFU Interface defines */
39 #include "rgr.h" /* RGR Interface defines */
40 #include "lrg.h" /* LRG Interface defines */
42 #include "rg_sch.h" /* Scheduler defines */
43 #include "rg_sch_inf.h" /* Scheduler defines */
44 #include "rg_sch_err.h" /* MAC error defines */
46 /* header/extern include files (.x) */
48 #include "tfu.x" /* TFU Interface defines */
49 #include "rgr.x" /* RGR Interface includes */
50 #include "lrg.x" /* LRG Interface includes */
52 #include "rg_sch_inf.x" /* Scheduler defines */
53 #include "rg_sch.x" /* Scheduler includes */
54 #include "rg_sch_cmn.h"
55 #include "rg_sch_cmn.x"
63 /* forward references */
66 uint32_t gUlRetxPassCntr = 0;
67 /*uint32_t gUlRetxFailCntr;
68 uint32_t gUlCrcPassCounter;
69 uint32_t gUlCrcFailCounter;*/
71 uint8_t rgRvIdxTable[] = {0, 3, 1, 2}; /* This gives rvIdx for a given rv */
72 uint8_t rgRvTable[] = {0, 2, 3 ,1}; /* This gives rv for a given rvIdx */
75 Void rgSCHCmnEmtcHdlHarqProcFail
79 RgSchUlHqProcCb *hqProc,
82 Void rgSCHEmtcInitUlUeHqEnt
92 * @brief Handler for HARQ processing on recieving Data indication from PHY.
96 * Function: rgSCHUhmProcDatInd
98 * Invoked by: rgSCHTomTfuDatInd of TOM
101 * - Set rcvdCrcInd variable to TRUE
108 #ifndef MAC_SCH_STATS
109 Void rgSCHUhmProcDatInd(RgSchCellCb *cell,RgSchUeCb *ue,CmLteTimingInfo frm)
110 #else /* MAC_SCH_STATS */
111 Void rgSCHUhmProcDatInd(RgSchCellCb *cell,RgSchUeCb *ue,CmLteTimingInfo frm,uint8_t cqi)
112 #endif /* MAC_SCH_STATS */
114 RgSchUlHqProcCb *hqProc;
116 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
118 uint8_t maxiTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend]
122 rgSCHUtlUlHqProcForUe(cell, frm, ue, &hqProc);
125 DU_LOG("\nERROR --> SCH : UE[%d] failed to find UL HqProc for [%d:%d]\n",
126 ue->ueId, frm.sfn, frm.slot);
129 hqProc->rcvdCrcInd = TRUE;
133 ueUl->ulLaCb.deltaiTbs += UL_LA_STEPUP;
134 iTbs = (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
138 ueUl->ulLaCb.deltaiTbs = (maxiTbs * 100) - ueUl->ulLaCb.cqiBasediTbs;
144 /** Stats update over here
147 hqFailStats.ulCqiStat[cqi - 1].numOfAcks++;
152 /* UL stats are filled in primary index as of now */
153 cell->tenbStats->sch.ulAckNack[rgRvTable[hqProc->rvIdx]]++;
154 ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulAckNackCnt++;
157 ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulTpt += (hqProc->alloc->grnt.datSz << 3);
158 cell->tenbStats->sch.ulTtlTpt +=(hqProc->alloc->grnt.datSz << 3);//pverma
163 } /* rgSCHUhmProcDatInd */
166 * @brief Handler for HARQ processing on recieving Data indication from PHY.
170 * Function: rgSCHUhmProcMsg3DatInd
172 * Invoked by: rgSCHTomTfuDatInd of TOM
175 * - Set rcvdCrcInd variable to TRUE
177 * @param[in,out] *hqProc
180 Void rgSCHUhmProcMsg3DatInd(RgSchUlHqProcCb *hqProc)
182 hqProc->rcvdCrcInd = TRUE;
183 hqProc->remTx = 0; /*Reseting the value of rem Tx*/
184 DU_LOG("\nINFO --> SCH : rgSCHUhmProcMsg3DatInd,id:%u\n",hqProc->procId);
186 } /* rgSCHUhmProcMsg3DatInd */
189 * @brief Handler for HARQ processing on recieving Data indication from PHY.
193 * Function: rgSCHUhmProcMsg3Failure
195 * Invoked by: rgSCHTomTfuDatInd of TOM
198 * - Set rcvdCrcInd variable to TRUE
200 * @param[in,out] *hqProc
203 Void rgSCHUhmProcMsg3Failure(RgSchUlHqProcCb *hqProc)
206 RG_SCH_EMTC_IS_CRCIND_RCVD_CHK_RACB(hqProc);
208 if(hqProc->rcvdCrcInd != TRUE)
210 hqProc->rcvdCrcInd = FALSE;
214 } /* rgSCHUhmProcMsg3Failure */
217 * @brief Handler for HARQ processing on recieving Decode failure from PHY.
221 * Function: rgSCHUhmProcHqFailure
223 * Invoked by: rgSCHTomTfuDecFailInd of TOM
226 * - Update NACK information in harq info.
227 * - Update RV index of received RV from PHY in harq info.
228 * - Set PhichInfo in DlSf
236 #ifndef MAC_SCH_STATS
237 Void rgSCHUhmProcHqFailure(RgSchCellCb *cell,RgSchUeCb *ue,CmLteTimingInfo frm,TknUInt8 rv)
238 #else /* MAC_SCH_STATS */
239 Void rgSCHUhmProcHqFailure(RgSchCellCb *cell,RgSchUeCb *ue,CmLteTimingInfo frm,TknUInt8 rv,uint8_t cqi)
240 #endif /* MAC_SCH_STATS */
242 RgSchUlHqProcCb *hqProc;
244 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
248 rgSCHUtlUlHqProcForUe(cell, frm, ue, &hqProc);
251 DU_LOG("\nERROR --> SCH : UE[%d] failed to find UL HqProc for [%d:%d]\n",
252 ue->ueId, frm.sfn, frm.slot);
257 ueUl->ulLaCb.deltaiTbs -= UL_LA_STEPDOWN;
258 iTbs = (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
262 ueUl->ulLaCb.deltaiTbs = -(ueUl->ulLaCb.cqiBasediTbs);
268 /** Stats update over here */
270 static uint32_t retxCnt = 0;
272 hqFailStats.ulCqiStat[cqi - 1].numOfNacks++;
274 #endif /* MAC_SCH_STATS */
275 if(hqProc->rcvdCrcInd != TRUE)
277 hqProc->rcvdCrcInd = FALSE;
280 /* UL stats are filled in primary index as of now */
281 cell->tenbStats->sch.ulAckNack[rgRvTable[hqProc->rvIdx]]++;
282 ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulAckNackCnt++;
283 cell->tenbStats->sch.ulNack[rgRvTable[hqProc->rvIdx]]++;
284 ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulNackCnt++;
286 hqProc->rvIdxPhy.pres = rv.pres;
289 hqProc->rvIdxPhy.val = rgRvIdxTable[rv.val];
292 } /* rgSCHUhmProcHqFailure */
295 * @brief Handler for identifying the HARQ process cb associated with the
300 * Function: rgSCHUhmGetUlHqProc
303 * - Return pointer to uplink harq process corresponding to the timing
304 * information passed.
308 * @return RgSchUlHqProcCb*
309 * -# Pointer to harq process corresponding to index
312 RgSchUlHqProcCb* rgSCHUhmGetUlHqProc(RgSchCellCb *cell,RgSchUeCb *ue, uint8_t idx)
314 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
316 #if (ERRCLASS & ERRCLS_DEBUG)
317 if(idx >= ueUl->hqEnt.numHqPrcs)
322 return (&(ueUl->hqEnt.hqProcCb[idx]));
323 } /* rgSCHUhmGetUlHqProc */
326 * @brief Handler for HARQ processing on recieving new trasmission indication
331 * Function: rgSCHUhmNewTx
336 * - Update harq info with values indicating new HARQ transmission.
338 * @param[in,out] *hqProc
342 Void rgSCHUhmNewTx(RgSchUlHqProcCb *hqProc,uint8_t maxHqRetx,RgSchUlAlloc *alloc)
346 hqProc->alloc = alloc;
347 hqProc->remTx = maxHqRetx;
348 hqProc->rcvdCrcInd = FALSE;
350 hqProc->rvIdxPhy.pres = FALSE;
352 if (hqProc->alloc->ue)
354 ((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs++;
358 } /* rgSCHUhmNewTx */
361 * @brief Free an uplink HARQ process.
365 * Function: rgSCHUhmFreeProc
370 * - Set alloc pointer to NULLP
372 * @param[in] RgSchUlHqProcCb *hqProc
373 * @param[in] RgSchCellCb *cell
376 Void rgSCHUhmFreeProc(RgSchUlHqProcCb *hqProc,RgSchCellCb *cell)
384 if (hqProc->alloc && hqProc->alloc->ue)
386 ueCb = hqProc->alloc->ue;
389 uint32_t nonLcg0ReportedBs = ((RgSchCmnLcg *)(ueCb->ul.lcgArr[1].sch))->reportedBs + \
390 ((RgSchCmnLcg *)(ueCb->ul.lcgArr[2].sch))->reportedBs + \
391 ((RgSchCmnLcg *)(ueCb->ul.lcgArr[3].sch))->reportedBs;
392 ((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs--;
393 if (! ((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs && !(nonLcg0ReportedBs))
395 while (ueCb->ulActiveLCs)
397 if (ueCb->ulActiveLCs & 0x1)
399 cell->qciArray[qci].ulUeCount--;
402 ueCb->ulActiveLCs >>= 1;
410 if(hqProc && (RgUeUlHqCb*)hqProc->hqEnt)
414 DU_LOG("\nDEBUG --> SCH : ########HARQ FREED HARQPROC ID (%d )after rgSCHUhmFreeProc inuse %ld free %ld \n",hqProc->alloc->grnt.hqProcId, (CmLListCp *)(&((RgUeUlHqCb*)hqProc->hqEnt)->inUse)->count,(CmLListCp *) (&((RgUeUlHqCb*)hqProc->hqEnt)->free)->count);
416 hqProc->alloc = NULLP;
417 hqProc->ulSfIdx = RGSCH_INVALID_INFO;
418 /*ccpu00116293 - Correcting relation between UL slot and DL slot based on RG_UL_DELTA*/
419 hqProc->isRetx = FALSE;
420 hqProc->remTx = 0; /*Reseting the remTx value to 0*/
422 RG_SCH_EMTC_SET_ISDTX_TO_FALSE(hqProc);
424 cmLListDelFrm(&((RgUeUlHqCb*)hqProc->hqEnt)->inUse,&hqProc->lnk);
425 cmLListAdd2Tail(&((RgUeUlHqCb*)hqProc->hqEnt)->free, &hqProc->lnk);
428 DU_LOG("\nINFO --> SCH : after rgSCHUhmFreeProc inuse %ld free %ld \n",
429 (CmLListCp *)(&((RgUeUlHqCb*)hqProc->hqEnt)->inUse)->count,
430 (CmLListCp *) (&((RgUeUlHqCb*)hqProc->hqEnt)->free)->count);
435 DU_LOG("\nERROR --> SCH : hqEnt is NULL\n");
438 } /* rgSCHUhmFreeProc */
441 * @brief Handler for HARQ processing on recieving re-trasmission
442 * indication from USM.
446 * Function: rgSCHUhmRetx
451 * - Update harq info with values corresponding to
454 * @param[in,out] *hqProc
457 Void rgSCHUhmRetx(RgSchUlHqProcCb *hqProc,RgSchUlAlloc *alloc)
460 hqProc->alloc = alloc;
462 hqProc->rvIdx = (hqProc->rvIdx + 1) % 4;
463 hqProc->rvIdxPhy.pres = FALSE;
469 * @brief Handler for initializing the HARQ entity.
473 * Function: rgSCHUhmRgrUeCfg
478 * - Initialize maxHqRetx
481 * @param[in,out] *ueCb
486 Void rgSCHUhmRgrUeCfg(RgSchCellCb *cellCb,RgSchUeCb *ueCb,RgrUeCfg *ueCfg)
489 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
491 ueUl->hqEnt.maxHqRetx = ((ueCfg->ueUlHqCfg.maxUlHqTx) - 1);
493 /* Storing the delta HARQ offset for HARQ + PUSCH */
494 ueCb->ul.betaHqOffst = ueCfg->puschDedCfg.bACKIdx;
496 cmLListInit(&ueUl->hqEnt.free);
497 cmLListInit(&ueUl->hqEnt.inUse);
498 for(i=0; i < ueUl->hqEnt.numHqPrcs; i++)
500 ueUl->hqEnt.hqProcCb[i].hqEnt = (void*)(&ueUl->hqEnt);
501 ueUl->hqEnt.hqProcCb[i].procId = i;
502 ueUl->hqEnt.hqProcCb[i].remTx = 0;
503 ueUl->hqEnt.hqProcCb[i].ulSfIdx = RGSCH_INVALID_INFO;
504 ueUl->hqEnt.hqProcCb[i].alloc = NULLP;
506 /* ccpu00139513- Initializing SPS flags*/
507 ueUl->hqEnt.hqProcCb[i].isSpsActvnHqP = FALSE;
508 ueUl->hqEnt.hqProcCb[i].isSpsOccnHqP = FALSE;
510 cmLListAdd2Tail(&ueUl->hqEnt.free, &ueUl->hqEnt.hqProcCb[i].lnk);
511 ueUl->hqEnt.hqProcCb[i].lnk.node = (PTR)&ueUl->hqEnt.hqProcCb[i];
515 rgSCHEmtcInitUlUeHqEnt(cellCb, ueCfg, ueCb);
518 } /* rgSCHUhmRgrUeCfg */
521 * @brief Handler for re-initializing the HARQ entity.
525 * Function: rgSCHUhmRgrUeRecfg
530 * - Re-initialize maxHqRetx
533 * @param[in,out] *ueCb
538 Void rgSCHUhmRgrUeRecfg(RgSchCellCb *cellCb,RgSchUeCb *ueCb,RgrUeRecfg *ueRecfg)
540 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
542 /* [ccpu00123958]-ADD- Check for HARQ Reconfig from the bit mask */
543 if(RGR_UE_ULHARQ_RECFG & ueRecfg->ueRecfgTypes)
545 ueUl->hqEnt.maxHqRetx = (ueRecfg->ueUlHqRecfg.maxUlHqTx - 1);
549 } /* rgSCHUhmRgrUeRecfg */
552 * @brief Handler for de-initializing the HARQ entity.
556 * Function: rgSCHUhmFreeUe
563 * @param[in,out] *ueCb
566 Void rgSCHUhmFreeUe(RgSchCellCb *cellCb,RgUeUlHqCb *hqEnt)
569 /* ccpu00117052 - MOD - Passing double pointer
570 for proper NULLP assignment*/
571 rgSCHUtlFreeSBuf(cellCb->instIdx,
572 (Data **)(&(hqEnt->hqProcCb)),
573 hqEnt->numHqPrcs * sizeof(RgSchUlHqProcCb));
577 } /* rgSCHUhmFreeUe */
581 * @brief Handler for appending the PHICH information in to the dlSf.
585 * Function: rgSCHUhmAppendPhich
590 * - Set PhichInfo in DlSf for each Hq
592 * @param[in] *RgSchCellCb
593 * @param[in] CmLteTimingInfo
597 S16 rgSCHUhmAppendPhich(RgSchCellCb *cellCb,CmLteTimingInfo frm,uint8_t idx)
604 RgSchUlAlloc *ulAlloc;
606 Bool allwNack = TRUE;
607 #endif /* LTEMAC_HDFDD */
608 RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cellCb);
613 if(cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
615 ulAlloc = rgSCHUtlFirstHqFdbkAlloc (cellCb, idx);
618 /*ccpu00106104 MOD added check for ACKNACK rep*/
619 /*added check for acknack so that adaptive retx considers ue
620 inactivity due to ack nack repetition*/
621 if((ulAlloc->ue != NULLP) && ((TRUE != ulAlloc->forMsg3) &&
622 ((ulAlloc->ue->measGapCb.isMeasuring == TRUE) ||
623 (ulAlloc->ue->ackNakRepCb.isAckNakRep == TRUE))))
625 /* Mark the UE for retransmission */
626 /* If UE is measuring then we should not be sending PHICH unless msg3 */
627 /*UE assumes ack, if nack then do adaptive re-transmission*/
628 /*ulAlloc->hqProc->rcvdCrcInd = FALSE;--*/
629 ulAlloc = rgSCHUtlNextHqFdbkAlloc (cellCb, ulAlloc, idx);
633 if (rgSCHUtlGetPhichInfo (ulAlloc->hqProc, &rbStart, &nDmrs, &iPhich) != ROK)
635 if (rgSCHUtlGetPhichInfo (ulAlloc->hqProc, &rbStart, &nDmrs) != ROK)
640 if(nDmrs != RGSCH_INVALID_NDMRS)
642 if(cellCb->dynCfiCb.switchOvrInProgress)
644 ulAlloc->hqProc->rcvdCrcInd = TRUE;
647 if(ulAlloc->hqProc->rcvdCrcInd)
650 rgSCHUtlAddPhich (cellCb, frm, TRUE, nDmrs, rbStart, iPhich);
652 rgSCHUtlAddPhich (cellCb, frm, TRUE, nDmrs, rbStart, ulAlloc->forMsg3);
655 /* Sending NACK in PHICH for failed UL TX */
659 rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, iPhich);
662 if (ulAlloc->ue != NULLP && ulAlloc->ue->hdFddEnbld)
664 rgSCHCmnHdFddChkNackAllow( cellCb, ulAlloc->ue, frm, &allwNack);
665 /* Present implementaion of non-HDFDD does not send phich req
666 incase of NACK. So commented this part to maintain same right
671 rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, ulAlloc->forMsg3);
675 rgSCHUtlAddPhich (cellCb, frm, TRUE, nDmrs, rbStart, ulAlloc->forMsg3);
680 rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, ulAlloc->forMsg3);
683 rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, ulAlloc->forMsg3);
684 #endif/* LTEMAC_HDFDD */
688 ulAlloc = rgSCHUtlNextHqFdbkAlloc (cellCb, ulAlloc, idx);
692 } /* rgSCHUhmAppendPhich */
695 * @brief This function initializes the DL HARQ Entity of UE.
699 * Function: rgSCHUhmHqEntInit
700 * Purpose: This function initializes the UL HARQ Processes of
701 * UE control block. This is performed at the time
702 * of creating UE control block.
704 * Invoked by: configuration module
706 * @param[in] RgSchUeCb* ueCb
712 S16 rgSCHUhmHqEntInit(RgSchCellCb *cellCb,RgSchUeCb *ueCb)
714 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
716 Inst inst = ueCb->cell->instIdx;
720 /* Init the HARQ processes */
721 ueUl->hqEnt.numHqPrcs = RGSCH_NUM_UL_HQ_PROC;
723 /* Init the HARQ processes */
724 ueUl->hqEnt.numHqPrcs =
725 rgSchTddUlNumHarqProcTbl[ueCb->cell->ulDlCfgIdx];
726 if (rgSCHUtlAllocSBuf(inst, (Data **)&ueUl->hqEnt.hqProcCb,
727 ueUl->hqEnt.numHqPrcs * \
728 sizeof(RgSchUlHqProcCb)) != ROK)
735 } /* rgSCHUhmHqEntInit */
739 * @brief This function gets an available HARQ process.
743 * Function: rgSCHUhmGetAvlHqProc
744 * Purpose: This function returns an available HARQ process in
745 * the UL direction. All HARQ processes are maintained
746 * in queues of free and inuse.
748 * 1. Check if the free queue is empty. If yes, return
750 * 2. If not empty, update the proc variable with the
751 * first process in the queue. Return ROK.
753 * Invoked by: scheduler
755 * @param[in] RgSchUeCb *ue
756 * @param[in] CmLteTimingInfo timingInfo
757 * @param[out] RgSchDlHqProc **hqP
759 * -#ROK if successful
760 * -#RFAILED otherwise
763 S16 rgSCHUhmGetAvlHqProc(RgSchCellCb *cell,RgSchUeCb *ue,RgSchUlHqProcCb **hqP)
765 RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
766 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
767 RgSchUlHqProcCb *tmpHqProc;
773 CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
777 //RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
778 // "rgSCHUhmGetAvlHqProc free %ld inUse %ld ue %d"
779 // , hqE->free.count, hqE->inUse.count, ue->ueId);
780 //DU_LOG("5GTF_ERROR rgSCHUhmGetAvlHqProc cellId %d %ld inUse %ld ue %d"
781 //, cell->cellId, hqE->free.count, hqE->inUse.count, ue->ueId);
782 /* No Harq Process available in the free queue. */
786 tmpHqProc = (RgSchUlHqProcCb *)(tmp->node);
788 /* Remove the element from the free Queue */
789 cmLListDelFrm(&hqE->free, tmp);
791 /* Add the element into the inUse Queue as well */
792 cmLListAdd2Tail(&hqE->inUse, &tmpHqProc->lnk);
795 DU_LOG("\nDEBUG --> SCH : rgSCHUhmGetAvlHqProc cellId %d free %ld inUse %ld UE %d time (%d %d)\n",cell->cellId, hqE->free.count, hqE->inUse.count, ue->ueId,cellUl->schdTime.sfn,cellUl->schdTime.slot);
797 tmpHqProc->schdTime = cellUl->schdTime;
802 } /* rgSCHUhmGetAvlHqProc */
805 * @brief Handler for identifying the HARQ process cb associated with the
810 * Function: rgSCHUhmGetUlProcByTime
813 * - Return pointer to uplink harq process corresponding to the timing
814 * information passed.
818 * @return RgSchUlHqProcCb*
819 * -# Pointer to harq process corresponding to index
822 RgSchUlHqProcCb* rgSCHUhmGetUlProcByTime(RgSchCellCb *cell,RgSchUeCb *ue, CmLteTimingInfo frm)
824 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
825 CmLListCp *lst = &ueUl->hqEnt.inUse;
826 CmLList *lnk = lst->first;
827 RgSchUlHqProcCb *proc;
831 proc = (RgSchUlHqProcCb *)(lnk->node);
833 // DU_LOG("\nINFO --> SCH : compare rgSCHUhmGetUlProcByTime time (%d %d) CRC time (%d %d) proc->procId %d
834 // \n",\proc->schdTime.sfn,proc->schdTime.slot,frm.sfn,frm.slot ,proc->procId);
835 if (RGSCH_TIMEINFO_SAME(proc->schdTime, frm))
837 // DU_LOG("\nINFO --> SCH : Harq timing Matched rgSCHUhmGetUlProcByTime time (%d %d) proc->procId %d \n",\
838 proc->schdTime.sfn,proc->schdTime.slot, proc->procId);
844 } /* rgSCHUhmGetUlProcByTime */
848 /**********************************************************************
851 **********************************************************************/