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 U32 gUlRetxPassCntr = 0;
67 /*EXTERN U32 gUlRetxFailCntr;
68 EXTERN U32 gUlCrcPassCounter;
69 EXTERN U32 gUlCrcFailCounter;*/
71 PUBLIC U8 rgRvIdxTable[] = {0, 3, 1, 2}; /* This gives rvIdx for a given rv */
72 PUBLIC U8 rgRvTable[] = {0, 2, 3 ,1}; /* This gives rv for a given rvIdx */
75 PUBLIC Void rgSCHCmnEmtcHdlHarqProcFail
79 RgSchUlHqProcCb *hqProc,
82 PUBLIC 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
110 PUBLIC Void rgSCHUhmProcDatInd
117 PUBLIC Void rgSCHUhmProcDatInd(cell, ue, frm)
122 #else /* MAC_SCH_STATS */
124 PUBLIC Void rgSCHUhmProcDatInd
132 PUBLIC Void rgSCHUhmProcDatInd(cell, ue, frm, cqi)
138 #endif /* MAC_SCH_STATS */
140 RgSchUlHqProcCb *hqProc;
142 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
144 U8 maxiTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend]
148 TRC2(rgSCHUhmProcDatInd);
150 rgSCHUtlUlHqProcForUe(cell, frm, ue, &hqProc);
153 printf("UE[%d] failed to find UL HqProc for [%d:%d]\n",
154 ue->ueId, frm.sfn, frm.slot);
157 hqProc->rcvdCrcInd = TRUE;
161 ueUl->ulLaCb.deltaiTbs += UL_LA_STEPUP;
162 iTbs = (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
166 ueUl->ulLaCb.deltaiTbs = (maxiTbs * 100) - ueUl->ulLaCb.cqiBasediTbs;
172 /** Stats update over here
175 hqFailStats.ulCqiStat[cqi - 1].numOfAcks++;
180 /* UL stats are filled in primary index as of now */
181 cell->tenbStats->sch.ulAckNack[rgRvTable[hqProc->rvIdx]]++;
182 ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulAckNackCnt++;
185 ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulTpt += (hqProc->alloc->grnt.datSz << 3);
186 cell->tenbStats->sch.ulTtlTpt +=(hqProc->alloc->grnt.datSz << 3);//pverma
191 } /* rgSCHUhmProcDatInd */
194 * @brief Handler for HARQ processing on recieving Data indication from PHY.
198 * Function: rgSCHUhmProcMsg3DatInd
200 * Invoked by: rgSCHTomTfuDatInd of TOM
203 * - Set rcvdCrcInd variable to TRUE
205 * @param[in,out] *hqProc
209 PUBLIC Void rgSCHUhmProcMsg3DatInd
211 RgSchUlHqProcCb *hqProc
214 PUBLIC Void rgSCHUhmProcMsg3DatInd(hqProc)
215 RgSchUlHqProcCb *hqProc;
218 TRC2(rgSCHUhmProcMsg3DatInd);
219 hqProc->rcvdCrcInd = TRUE;
220 hqProc->remTx = 0; /*Reseting the value of rem Tx*/
221 printf("\nrgSCHUhmProcMsg3DatInd,id:%u\n",hqProc->procId);
223 } /* rgSCHUhmProcMsg3DatInd */
226 * @brief Handler for HARQ processing on recieving Data indication from PHY.
230 * Function: rgSCHUhmProcMsg3Failure
232 * Invoked by: rgSCHTomTfuDatInd of TOM
235 * - Set rcvdCrcInd variable to TRUE
237 * @param[in,out] *hqProc
241 PUBLIC Void rgSCHUhmProcMsg3Failure
243 RgSchUlHqProcCb *hqProc
246 PUBLIC Void rgSCHUhmProcMsg3Failure(hqProc)
247 RgSchUlHqProcCb *hqProc;
250 TRC2(rgSCHUhmProcMsg3Failure);
252 RG_SCH_EMTC_IS_CRCIND_RCVD_CHK_RACB(hqProc);
254 if(hqProc->rcvdCrcInd != TRUE)
256 hqProc->rcvdCrcInd = FALSE;
260 } /* rgSCHUhmProcMsg3Failure */
263 * @brief Handler for HARQ processing on recieving Decode failure from PHY.
267 * Function: rgSCHUhmProcHqFailure
269 * Invoked by: rgSCHTomTfuDecFailInd of TOM
272 * - Update NACK information in harq info.
273 * - Update RV index of received RV from PHY in harq info.
274 * - Set PhichInfo in DlSf
282 #ifndef MAC_SCH_STATS
284 PUBLIC Void rgSCHUhmProcHqFailure
292 PUBLIC Void rgSCHUhmProcHqFailure(cell, ue, frm, rv)
298 #else /* MAC_SCH_STATS */
300 PUBLIC Void rgSCHUhmProcHqFailure
309 PUBLIC Void rgSCHUhmProcHqFailure(cell, ue, frm, rv, cqi)
316 #endif /* MAC_SCH_STATS */
318 RgSchUlHqProcCb *hqProc;
320 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
323 TRC2(rgSCHUhmProcHqFailure);
325 rgSCHUtlUlHqProcForUe(cell, frm, ue, &hqProc);
328 printf("UE[%d] failed to find UL HqProc for [%d:%d]\n",
329 ue->ueId, frm.sfn, frm.slot);
334 ueUl->ulLaCb.deltaiTbs -= UL_LA_STEPDOWN;
335 iTbs = (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
339 ueUl->ulLaCb.deltaiTbs = -(ueUl->ulLaCb.cqiBasediTbs);
345 /** Stats update over here */
347 static U32 retxCnt = 0;
349 hqFailStats.ulCqiStat[cqi - 1].numOfNacks++;
351 #endif /* MAC_SCH_STATS */
352 if(hqProc->rcvdCrcInd != TRUE)
354 hqProc->rcvdCrcInd = FALSE;
357 /* UL stats are filled in primary index as of now */
358 cell->tenbStats->sch.ulAckNack[rgRvTable[hqProc->rvIdx]]++;
359 ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulAckNackCnt++;
360 cell->tenbStats->sch.ulNack[rgRvTable[hqProc->rvIdx]]++;
361 ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulNackCnt++;
363 hqProc->rvIdxPhy.pres = rv.pres;
366 hqProc->rvIdxPhy.val = rgRvIdxTable[rv.val];
369 } /* rgSCHUhmProcHqFailure */
372 * @brief Handler for identifying the HARQ process cb associated with the
377 * Function: rgSCHUhmGetUlHqProc
380 * - Return pointer to uplink harq process corresponding to the timing
381 * information passed.
385 * @return RgSchUlHqProcCb*
386 * -# Pointer to harq process corresponding to index
390 PUBLIC RgSchUlHqProcCb* rgSCHUhmGetUlHqProc
397 PUBLIC RgSchUlHqProcCb* rgSCHUhmGetUlHqProc(cell, ue, idx)
403 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
404 TRC2(rgSCHUhmGetUlHqProc);
406 #if (ERRCLASS & ERRCLS_DEBUG)
407 if(idx >= ueUl->hqEnt.numHqPrcs)
412 return (&(ueUl->hqEnt.hqProcCb[idx]));
413 } /* rgSCHUhmGetUlHqProc */
416 * @brief Handler for HARQ processing on recieving new trasmission indication
421 * Function: rgSCHUhmNewTx
426 * - Update harq info with values indicating new HARQ transmission.
428 * @param[in,out] *hqProc
433 PUBLIC Void rgSCHUhmNewTx
435 RgSchUlHqProcCb *hqProc,
440 PUBLIC Void rgSCHUhmNewTx(hqProc, maxHqRetx, alloc)
441 RgSchUlHqProcCb *hqProc;
449 hqProc->alloc = alloc;
450 hqProc->remTx = maxHqRetx;
451 hqProc->rcvdCrcInd = FALSE;
453 hqProc->rvIdxPhy.pres = FALSE;
455 if (hqProc->alloc->ue)
457 ((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs++;
461 } /* rgSCHUhmNewTx */
464 * @brief Free an uplink HARQ process.
468 * Function: rgSCHUhmFreeProc
473 * - Set alloc pointer to NULLP
475 * @param[in] RgSchUlHqProcCb *hqProc
476 * @param[in] RgSchCellCb *cell
480 PUBLIC Void rgSCHUhmFreeProc
482 RgSchUlHqProcCb *hqProc,
486 PUBLIC Void rgSCHUhmFreeProc(hqProc, cell)
487 RgSchUlHqProcCb *hqProc;
495 TRC2(rgSCHUhmFreeProc);
498 if (hqProc->alloc && hqProc->alloc->ue)
500 ueCb = hqProc->alloc->ue;
503 U32 nonLcg0ReportedBs = ((RgSchCmnLcg *)(ueCb->ul.lcgArr[1].sch))->reportedBs + \
504 ((RgSchCmnLcg *)(ueCb->ul.lcgArr[2].sch))->reportedBs + \
505 ((RgSchCmnLcg *)(ueCb->ul.lcgArr[3].sch))->reportedBs;
506 ((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs--;
507 if (! ((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs && !(nonLcg0ReportedBs))
509 while (ueCb->ulActiveLCs)
511 if (ueCb->ulActiveLCs & 0x1)
513 cell->qciArray[qci].ulUeCount--;
516 ueCb->ulActiveLCs >>= 1;
524 if(hqProc && (RgUeUlHqCb*)hqProc->hqEnt)
528 printf("\n\n########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);
530 hqProc->alloc = NULLP;
531 hqProc->ulSfIdx = RGSCH_INVALID_INFO;
532 /*ccpu00116293 - Correcting relation between UL slot and DL slot based on RG_UL_DELTA*/
533 hqProc->isRetx = FALSE;
534 hqProc->remTx = 0; /*Reseting the remTx value to 0*/
536 RG_SCH_EMTC_SET_ISDTX_TO_FALSE(hqProc);
538 cmLListDelFrm(&((RgUeUlHqCb*)hqProc->hqEnt)->inUse,&hqProc->lnk);
539 cmLListAdd2Tail(&((RgUeUlHqCb*)hqProc->hqEnt)->free, &hqProc->lnk);
542 printf("after rgSCHUhmFreeProc inuse %ld free %ld \n",
543 (CmLListCp *)(&((RgUeUlHqCb*)hqProc->hqEnt)->inUse)->count,
544 (CmLListCp *) (&((RgUeUlHqCb*)hqProc->hqEnt)->free)->count);
549 printf("\nhqEnt is NULL\n");
552 } /* rgSCHUhmFreeProc */
555 * @brief Handler for HARQ processing on recieving re-trasmission
556 * indication from USM.
560 * Function: rgSCHUhmRetx
565 * - Update harq info with values corresponding to
568 * @param[in,out] *hqProc
572 PUBLIC Void rgSCHUhmRetx
574 RgSchUlHqProcCb *hqProc,
578 PUBLIC Void rgSCHUhmRetx(hqProc, alloc)
579 RgSchUlHqProcCb *hqProc;
585 hqProc->alloc = alloc;
587 hqProc->rvIdx = (hqProc->rvIdx + 1) % 4;
588 hqProc->rvIdxPhy.pres = FALSE;
594 * @brief Handler for initializing the HARQ entity.
598 * Function: rgSCHUhmRgrUeCfg
603 * - Initialize maxHqRetx
606 * @param[in,out] *ueCb
612 PUBLIC Void rgSCHUhmRgrUeCfg
619 PUBLIC Void rgSCHUhmRgrUeCfg(cellCb, ueCb, ueCfg)
626 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
628 TRC2(rgSCHUhmRgrUeCfg);
630 ueUl->hqEnt.maxHqRetx = ((ueCfg->ueUlHqCfg.maxUlHqTx) - 1);
632 /* Storing the delta HARQ offset for HARQ + PUSCH */
633 ueCb->ul.betaHqOffst = ueCfg->puschDedCfg.bACKIdx;
635 cmLListInit(&ueUl->hqEnt.free);
636 cmLListInit(&ueUl->hqEnt.inUse);
637 for(i=0; i < ueUl->hqEnt.numHqPrcs; i++)
639 ueUl->hqEnt.hqProcCb[i].hqEnt = (void*)(&ueUl->hqEnt);
640 ueUl->hqEnt.hqProcCb[i].procId = i;
641 ueUl->hqEnt.hqProcCb[i].remTx = 0;
642 ueUl->hqEnt.hqProcCb[i].ulSfIdx = RGSCH_INVALID_INFO;
643 ueUl->hqEnt.hqProcCb[i].alloc = NULLP;
645 /* ccpu00139513- Initializing SPS flags*/
646 ueUl->hqEnt.hqProcCb[i].isSpsActvnHqP = FALSE;
647 ueUl->hqEnt.hqProcCb[i].isSpsOccnHqP = FALSE;
649 cmLListAdd2Tail(&ueUl->hqEnt.free, &ueUl->hqEnt.hqProcCb[i].lnk);
650 ueUl->hqEnt.hqProcCb[i].lnk.node = (PTR)&ueUl->hqEnt.hqProcCb[i];
654 rgSCHEmtcInitUlUeHqEnt(cellCb, ueCfg, ueCb);
657 } /* rgSCHUhmRgrUeCfg */
660 * @brief Handler for re-initializing the HARQ entity.
664 * Function: rgSCHUhmRgrUeRecfg
669 * - Re-initialize maxHqRetx
672 * @param[in,out] *ueCb
678 PUBLIC Void rgSCHUhmRgrUeRecfg
685 PUBLIC Void rgSCHUhmRgrUeRecfg(cellCb, ueCb, ueRecfg)
691 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
692 TRC2(rgSCHUhmRgrUeRecfg);
694 /* [ccpu00123958]-ADD- Check for HARQ Reconfig from the bit mask */
695 if(RGR_UE_ULHARQ_RECFG & ueRecfg->ueRecfgTypes)
697 ueUl->hqEnt.maxHqRetx = (ueRecfg->ueUlHqRecfg.maxUlHqTx - 1);
701 } /* rgSCHUhmRgrUeRecfg */
704 * @brief Handler for de-initializing the HARQ entity.
708 * Function: rgSCHUhmFreeUe
715 * @param[in,out] *ueCb
719 PUBLIC Void rgSCHUhmFreeUe
725 PUBLIC Void rgSCHUhmFreeUe(cellCb, hqEnt)
730 TRC2(rgSCHUhmFreeUe);
732 /* ccpu00117052 - MOD - Passing double pointer
733 for proper NULLP assignment*/
734 rgSCHUtlFreeSBuf(cellCb->instIdx,
735 (Data **)(&(hqEnt->hqProcCb)),
736 hqEnt->numHqPrcs * sizeof(RgSchUlHqProcCb));
740 } /* rgSCHUhmFreeUe */
744 * @brief Handler for appending the PHICH information in to the dlSf.
748 * Function: rgSCHUhmAppendPhich
753 * - Set PhichInfo in DlSf for each Hq
755 * @param[in] *RgSchCellCb
756 * @param[in] CmLteTimingInfo
761 PUBLIC S16 rgSCHUhmAppendPhich
768 PUBLIC S16 rgSCHUhmAppendPhich (cellCb, frm, idx)
779 RgSchUlAlloc *ulAlloc;
781 Bool allwNack = TRUE;
782 #endif /* LTEMAC_HDFDD */
783 RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cellCb);
785 TRC2(rgSCHUhmAppendPhich)
790 if(cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
792 ulAlloc = rgSCHUtlFirstHqFdbkAlloc (cellCb, idx);
795 /*ccpu00106104 MOD added check for ACKNACK rep*/
796 /*added check for acknack so that adaptive retx considers ue
797 inactivity due to ack nack repetition*/
798 if((ulAlloc->ue != NULLP) && ((TRUE != ulAlloc->forMsg3) &&
799 ((ulAlloc->ue->measGapCb.isMeasuring == TRUE) ||
800 (ulAlloc->ue->ackNakRepCb.isAckNakRep == TRUE))))
802 /* Mark the UE for retransmission */
803 /* If UE is measuring then we should not be sending PHICH unless msg3 */
804 /*UE assumes ack, if nack then do adaptive re-transmission*/
805 /*ulAlloc->hqProc->rcvdCrcInd = FALSE;--*/
806 ulAlloc = rgSCHUtlNextHqFdbkAlloc (cellCb, ulAlloc, idx);
810 if (rgSCHUtlGetPhichInfo (ulAlloc->hqProc, &rbStart, &nDmrs, &iPhich) != ROK)
812 if (rgSCHUtlGetPhichInfo (ulAlloc->hqProc, &rbStart, &nDmrs) != ROK)
817 if(nDmrs != RGSCH_INVALID_NDMRS)
819 if(cellCb->dynCfiCb.switchOvrInProgress)
821 ulAlloc->hqProc->rcvdCrcInd = TRUE;
824 if(ulAlloc->hqProc->rcvdCrcInd)
827 rgSCHUtlAddPhich (cellCb, frm, TRUE, nDmrs, rbStart, iPhich);
829 rgSCHUtlAddPhich (cellCb, frm, TRUE, nDmrs, rbStart, ulAlloc->forMsg3);
832 /* Sending NACK in PHICH for failed UL TX */
836 rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, iPhich);
839 if (ulAlloc->ue != NULLP && ulAlloc->ue->hdFddEnbld)
841 rgSCHCmnHdFddChkNackAllow( cellCb, ulAlloc->ue, frm, &allwNack);
842 /* Present implementaion of non-HDFDD does not send phich req
843 incase of NACK. So commented this part to maintain same right
848 rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, ulAlloc->forMsg3);
852 rgSCHUtlAddPhich (cellCb, frm, TRUE, nDmrs, rbStart, ulAlloc->forMsg3);
857 rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, ulAlloc->forMsg3);
860 rgSCHUtlAddPhich (cellCb, frm, FALSE, nDmrs, rbStart, ulAlloc->forMsg3);
861 #endif/* LTEMAC_HDFDD */
865 ulAlloc = rgSCHUtlNextHqFdbkAlloc (cellCb, ulAlloc, idx);
869 } /* rgSCHUhmAppendPhich */
872 * @brief This function initializes the DL HARQ Entity of UE.
876 * Function: rgSCHUhmHqEntInit
877 * Purpose: This function initializes the UL HARQ Processes of
878 * UE control block. This is performed at the time
879 * of creating UE control block.
881 * Invoked by: configuration module
883 * @param[in] RgSchUeCb* ueCb
890 PUBLIC S16 rgSCHUhmHqEntInit
896 PUBLIC S16 rgSCHUhmHqEntInit(cellCb, ueCb)
901 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
903 Inst inst = ueCb->cell->instIdx;
905 TRC2(rgSCHUhmHqEntInit)
908 /* Init the HARQ processes */
909 ueUl->hqEnt.numHqPrcs = RGSCH_NUM_UL_HQ_PROC;
911 /* Init the HARQ processes */
912 ueUl->hqEnt.numHqPrcs =
913 rgSchTddUlNumHarqProcTbl[ueCb->cell->ulDlCfgIdx];
914 if (rgSCHUtlAllocSBuf(inst, (Data **)&ueUl->hqEnt.hqProcCb,
915 ueUl->hqEnt.numHqPrcs * \
916 sizeof(RgSchUlHqProcCb)) != ROK)
923 } /* rgSCHUhmHqEntInit */
927 * @brief This function gets an available HARQ process.
931 * Function: rgSCHUhmGetAvlHqProc
932 * Purpose: This function returns an available HARQ process in
933 * the UL direction. All HARQ processes are maintained
934 * in queues of free and inuse.
936 * 1. Check if the free queue is empty. If yes, return
938 * 2. If not empty, update the proc variable with the
939 * first process in the queue. Return ROK.
941 * Invoked by: scheduler
943 * @param[in] RgSchUeCb *ue
944 * @param[in] CmLteTimingInfo timingInfo
945 * @param[out] RgSchDlHqProc **hqP
947 * -#ROK if successful
948 * -#RFAILED otherwise
952 PUBLIC S16 rgSCHUhmGetAvlHqProc
956 RgSchUlHqProcCb **hqP
959 PUBLIC S16 rgSCHUhmGetAvlHqProc (cell, ue, hqP)
962 RgSchUlHqProcCb **hqP;
965 RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
966 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
967 RgSchUlHqProcCb *tmpHqProc;
971 TRC2(rgSCHUhmGetAvlHqProc);
975 CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
979 //RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
980 // "rgSCHUhmGetAvlHqProc free %ld inUse %ld ue %d"
981 // , hqE->free.count, hqE->inUse.count, ue->ueId);
982 //printf("5GTF_ERROR rgSCHUhmGetAvlHqProc cellId %d %ld inUse %ld ue %d"
983 //, cell->cellId, hqE->free.count, hqE->inUse.count, ue->ueId);
984 /* No Harq Process available in the free queue. */
988 tmpHqProc = (RgSchUlHqProcCb *)(tmp->node);
990 /* Remove the element from the free Queue */
991 cmLListDelFrm(&hqE->free, tmp);
993 /* Add the element into the inUse Queue as well */
994 cmLListAdd2Tail(&hqE->inUse, &tmpHqProc->lnk);
997 printf("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);
999 tmpHqProc->schdTime = cellUl->schdTime;
1004 } /* rgSCHUhmGetAvlHqProc */
1007 * @brief Handler for identifying the HARQ process cb associated with the
1012 * Function: rgSCHUhmGetUlProcByTime
1015 * - Return pointer to uplink harq process corresponding to the timing
1016 * information passed.
1020 * @return RgSchUlHqProcCb*
1021 * -# Pointer to harq process corresponding to index
1025 PUBLIC RgSchUlHqProcCb* rgSCHUhmGetUlProcByTime
1032 PUBLIC RgSchUlHqProcCb* rgSCHUhmGetUlProcByTime(cell, ue, frm)
1035 CmLteTimingInfo frm;
1038 RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
1039 CmLListCp *lst = &ueUl->hqEnt.inUse;
1040 CmLList *lnk = lst->first;
1041 RgSchUlHqProcCb *proc;
1043 TRC2(rgSCHUhmGetUlProcByTime);
1047 proc = (RgSchUlHqProcCb *)(lnk->node);
1049 // printf("compare rgSCHUhmGetUlProcByTime time (%d %d) CRC time (%d %d) proc->procId %d \n",proc->schdTime.sfn,proc->schdTime.slot,frm.sfn,frm.slot ,proc->procId);
1050 if (RGSCH_TIMEINFO_SAME(proc->schdTime, frm))
1052 // printf("Harq timing Matched rgSCHUhmGetUlProcByTime time (%d %d) proc->procId %d \n",proc->schdTime.sfn,proc->schdTime.slot, proc->procId);
1058 } /* rgSCHUhmGetUlProcByTime */
1062 /**********************************************************************
1065 **********************************************************************/